应该对数组进行相同排序的两个代码，不要答案

【问题标题】：Two codes that should act the same sorting an array, don't应该对数组进行相同排序的两个代码，不要
【发布时间】：2020-04-04 15:33:13
【问题描述】：

尝试按升序对同一数组进行排序。

我不明白这两个代码之间的区别。结果不同，因为在第二个代码中，最大的数字立即排在最后一位，而在第一个代码中，最小的数字排在第一位。这就像相反的方法。但是我不明白代码的区别在哪里，可能是因为我是新手。

这两者中最好的代码是什么？

第一个代码：

#include <stdio.h>

#define SIZE 10

int main(){
    unsigned int array[] = {3,1,9,6,0,54,4,12,52,44};

    for (unsigned int i=0;i<=SIZE-1;++i){
        for (unsigned int j=i+1;j<=SIZE-1;++j){
            if (array[i] > array[j]){
                int hold = array[i];
                array[i] = array[j];
                array[j] = hold;
            }
        }
        printf("At the @%d pass:\n", i);
        for (unsigned int k=0; k<=SIZE-1; ++k){
            printf("%d\n", array[k]);
        }
        puts("");
    }
}

输出：

At the @0 pass:
0
3
9
6
1
54
4
12
52
44

At the @1 pass:
0
1
9
6
3
54
4
12
52
44

At the @2 pass:
0
1
3
9
6
54
4
12
52
44

At the @3 pass:
0
1
3
4
9
54
6
12
52
44

At the @4 pass:
0
1
3
4
6
54
9
12
52
44

At the @5 pass:
0
1
3
4
6
9
54
12
52
44

At the @6 pass:
0
1
3
4
6
9
12
54
52
44

At the @7 pass:
0
1
3
4
6
9
12
44
54
52

At the @8 pass:
0
1
3
4
6
9
12
44
52
54

At the @9 pass:
0
1
3
4
6
9
12
44
52
54

第二个代码：

#include <stdio.h>

#define SIZE 10

int main(){
    unsigned int array[] = {3,1,9,6,0,54,4,12,52,44};

    for (unsigned int pass=1;pass<SIZE;++pass){
        for (size_t i=0;i < SIZE-1; ++i){
            if (array[i] > array[i+1]){
                int hold = array[i];
                array[i] = array[i+1];
                array[i+1] = hold;
            }
        }
        printf("At the @%d pass:\n", pass);
        for (unsigned int k=0; k<=SIZE-1; ++k){
            printf("%d\n", array[k]);
        }
        puts("");
    }
}

输出：

At the @1 pass:
1
3
6
0
9
4
12
52
44
54

At the @2 pass:
1
3
0
6
4
9
12
44
52
54

At the @3 pass:
1
0
3
4
6
9
12
44
52
54

At the @4 pass:
0
1
3
4
6
9
12
44
52
54

At the @5 pass:
0
1
3
4
6
9
12
44
52
54

At the @6 pass:
0
1
3
4
6
9
12
44
52
54

At the @7 pass:
0
1
3
4
6
9
12
44
52
54

At the @8 pass:
0
1
3
4
6
9
12
44
52
54

At the @9 pass:
0
1
3
4
6
9
12
44
52
54

【问题讨论】：

第一个看起来像选择排序en.wikipedia.org/wiki/Selection_sort，第二个看起来像冒泡排序en.wikipedia.org/wiki/Bubble_sort。有区别，但不是真正的“相反方法”。
第二个从 1 开始，第一个从 0 开始？你也应该为每个算法创建函数
内部循环从不同的索引开始。在第一个代码中，您使用两个循环变量进行交换。在第二个代码中，您只使用内部循环变量进行交换，内部循环解析整个数组。它们不是相同的代码，但它们给出相同的最终结果。不同的代码 - 不同的部分排序。为什么它们会一样？
请注意，第一个代码需要 9 遍才能排序，第二个代码只需要 4 遍。

标签： c arrays sorting

【解决方案1】：

看第一个代码的这个sn-p：

    for (unsigned int i=0;i<=SIZE-1;++i){
        for (unsigned int j=i+1;j<=SIZE-1;++j){
            if (array[i] > array[j]){
                int hold = array[i];
                array[i] = array[j];
                array[j] = hold;
            }
        }
        .......

在此选择元素 array[i] 并与内部循环中从 i+1 位置开始的其余数组元素进行比较，如果它大于 array[j] 的任何元素，则交换。因此，剩余数组中的最小数字将在每次迭代中转到数组中的[i] 位置。这是选择排序。

看第二个代码的这个sn-p：

    for (unsigned int pass=1;pass<SIZE;++pass){
        for (size_t i=0;i < SIZE-1; ++i){
            if (array[i] > array[i+1]){
                int hold = array[i];
                array[i] = array[i+1];
                array[i+1] = hold;
            }
        }
        ......

在这种情况下，内部循环比较两个连续元素，如果条件满足则交换它们。这是冒泡排序。

【讨论】：