Python 3.x 冒泡排序大大优于选择排序

我目前正在尝试理解排序算法，并且一直在研究伪代码并将其转换为python（使用python 3.6，IDE是Spyder 3.1.2）。我写了一个简单的气泡排序：

def BubbleSort(array_to_sort):
    n = len(array_to_sort) - 1
    swapped = True
    while (swapped):
        swapped = False
        for i in range(n):
             if array_to_sort[i] > array_to_sort[i+1]:
                array_to_sort[i+1], array_to_sort[i] = array_to_sort[i], array_to_sort[i+1] 
                swapped = True
    return array_to_sort

还有一个简单的选择排序：

def SelectionSort(array_to_sort):
    n = len(array_to_sort)
    for i in range(n):
        minPos = i
        for j in range(i+1, n):
            if array_to_sort[j] < array_to_sort[minPos]:
                minPos=j

        if minPos != i:
            array_to_sort[i], array_to_sort[minPos] = array_to_sort[minPos], array_to_sort[i] 

    return array_to_sort

RandomNumberRay只是生成一个我想排序的数字列表：

def RandomNumberArray():
    return random.sample(range(0, 1000), 1000)

由于它们都具有相同的时间复杂度O（n2），我希望它们所花费的时间大致相同，但是我发现我的选择排序的性能比冒泡排序更差，例如，对于1000次迭代中包含1000个数字的数组-
BS结果：0.390秒
SS结果：63.618秒

以及超过10000次迭代的1000个数字的数组-
BS结果：2.074 s
SS结果：645.944秒

---

这些算法的实现是否存在问题，或者预期会有如此大的差异？我知道还有其他更快的排序，实际上没有人会真正使用BS或SS，但我只是想弄明白为什么SS看起来比BS慢那么多？

这不是一个公平的比较，因为

数组

按第一次调用排序，然后传递给第二次调用。有几种排序算法，其中已排序的输入是最坏的情况

---

冒泡排序也有O（n）个最佳情况时间复杂度，而选择有O（n^2）个最佳情况。

这不是一个公平的比较，因为

array

按第一个调用排序，然后传递给第二个调用。有几种排序算法，其中已排序的输入是最坏的情况

---

冒泡排序也有O（n）个最佳情况时间复杂度，而选择有O（n^2）个最佳情况。

User@richard指出了主要问题

总的来说，我希望写得好的冒泡排序每次都比选择排序好。冒泡排序编写得不是特别好，因为它没有利用算法在外部循环每次迭代后提供的偏序。也就是说，你有：

def BubbleSort(array_to_sort):
    n = len(array_to_sort) - 1
    swapped = True
    while (swapped):
        swapped = False
        for i in range(n):
             if array_to_sort[i] > array_to_sort[i+1]:
                array_to_sort[i+1], array_to_sort[i] = array_to_sort[i], array_to_sort[i+1] 
                swapped = True
    return array_to_sort

每次通过外循环时，都会有一个项目按顺序推送到数组的末尾。也就是说，第一次通过循环时，最大项目被推到最后一个位置。下一次，第二大的将被推到倒数第二的位置，等等。但是您的代码并没有利用这一点。相反，它会不断比较已排序的项目。您可以通过以下方法显著改进代码：

def BubbleSort(array_to_sort):
    n = len(array_to_sort) - 1
    swapped = True
    j = 0
    while (swapped):
        swapped = False
        for i in range(0, n-j):
             if array_to_sort[i] > array_to_sort[i+1]:
                array_to_sort[i+1], array_to_sort[i] = array_to_sort[i], array_to_sort[i+1] 
                swapped = True
        ++j;
    return array_to_sort

---

冒泡排序通常比选择排序快，原因有两个：1）有一个“提前退出”选项，允许您在未进行交换时退出。2） 参考位置更好；你总是比较和交换相邻的项目。

User@richard指出了主要问题

总的来说，我希望写得好的冒泡排序每次都比选择排序好。冒泡排序编写得不是特别好，因为它没有利用算法在外部循环每次迭代后提供的偏序。也就是说，你有：

def BubbleSort(array_to_sort):
    n = len(array_to_sort) - 1
    swapped = True
    while (swapped):
        swapped = False
        for i in range(n):
             if array_to_sort[i] > array_to_sort[i+1]:
                array_to_sort[i+1], array_to_sort[i] = array_to_sort[i], array_to_sort[i+1] 
                swapped = True
    return array_to_sort

每次通过外循环时，都会有一个项目按顺序推送到数组的末尾。也就是说，第一次通过循环时，最大项目被推到最后一个位置。下一次，第二大的将被推到倒数第二的位置，等等。但是您的代码并没有利用这一点。相反，它会不断比较已排序的项目。您可以通过以下方法显著改进代码：

def BubbleSort(array_to_sort):
    n = len(array_to_sort) - 1
    swapped = True
    j = 0
    while (swapped):
        swapped = False
        for i in range(0, n-j):
             if array_to_sort[i] > array_to_sort[i+1]:
                array_to_sort[i+1], array_to_sort[i] = array_to_sort[i], array_to_sort[i+1] 
                swapped = True
        ++j;
    return array_to_sort

---

冒泡排序通常比选择排序快，原因有两个：1）有一个“提前退出”选项，允许您在未进行交换时退出。2） 参考位置更好；您总是在比较和交换相邻的项。

冒泡排序的一个更有价值的优化是利用迭代进行的最后一次交换使数组的尾部（超出该点）处于最终状态。例如，在第一次传递中：

a = [2, 1, 3, 4, 5, 6, 7, 8, 9, 10]

---

只有

a[0]

和

a[1]

被交换，这意味着不需要做更多的事情。第一步已经确定，

a[0]
a = [2, 1, 3, 4, 5, 6, 7, 8, 9, 10]

只有
a[0]
和
a[1]
被交换，这意味着不需要做更多的事情。第一次通过已经确定
a[0]ret=array\u to_sort[：]
，然后不使用原始函数，返回
ret
。糟糕，这是一个愚蠢的错误。。。修复后，我仍然看到时间上的差异（不是645秒，SS降到162秒，仍然比BS所需的1秒大得多），如果你正确地修复了它，那么BS的时间应该比tim快得多