是否正确，如果冒泡排序的第一遍将最小的气泡放在第 0 位？

Question

从 GeeksforGeeks 我发现了这个定义：

冒泡排序是最简单的排序算法，如果相邻元素的顺序错误，它会重复交换相邻元素。

例子：

第一关：
 ( 5 1 4 2 8 ) -> ( 1 5 4 2 8 )，这里，算法比较前两个元素，并从 5 > 1 开始交换。
 ( 1 5 4 2 8 ) –> ( 1 4 5 2 8 )，从 5 > 4 开始交换
 ( 1 4 5 2 8 ) –> ( 1 4 2 5 8 )，从 5 > 2 开始交换
 ( 1 4 2 5 8 ) -> ( 1 4 2 5 8 ), 现在，由于这些元素已经有序 (8 > 5)，算法不会交换它们。

第二关：
 (1 4 2 5 8) -> (1 4 2 5 8)
 ( 1 4 2 5 8 ) –> ( 1 2 4 5 8 )，从 4 > 2 开始交换
 (1 2 4 5 8) -> (1 2 4 5 8)
 (1 2 4 5 8) -> (1 2 4 5 8)

现在，数组已经排好序了，但是我们的算法不知道它是否完成了。 该算法需要一整遍而不进行任何交换才能知道它已排序。

如果我以从 n-1 到 0 的相反顺序执行此操作怎么办？ 是否正确，因为我将数组的最小气泡放在第一遍的第一个位置。

我这样写我的代码：

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

Answer 1

是的，您的代码将起作用。

但是为了提高程序在速度方面的效率，您应该更改第二个for循环中的条件。 正如你所写

for (int j = array.length - 1; j > 0; j--) {
    ...
}

这里，在 Second Pass 中，当j的值为 1 时，它会不必要地检查这个条件

array[j - 1] > array[j]

因为，在第一遍之后， array[0]已经是最小的了。 因此，您无需再次检查。

而在第三遍中，会有两个不必要的条件等等。

因此，我建议您使用j > i作为第二个for Loop 的条件。 那么你的整条线将是

for (int j = array.length - 1; j > i; j--) {
    ...
}

Answer 2

这个想法最终是对列表进行排序。

下面是先填充最小数字再填充最大数字的 Python 代码

def selection_sort(input_list):
    for init in range(0,len(input_list)):
        pos_of_min=init        
        for nxt in range(pos_of_min+1,len(input_list)):
            if input_list[pos_of_min]>input_list[nxt]:
                pos_of_min=nxt
        input_list[init]=input_list[pos_of_min]
        input_list[pos_of_min]=input_list[init]
    return input_list


arr_unsorted=[25,67,23,21,90,89,45,63]
sorted_result=selection_sort(arr_unsorted)
print(sorted_result)