数据结构与算法（Python）（六）—— 排序算法（1）冒泡排序

排序算法

• 排序算法是一种能将一串数据依照特定顺序进行排列的一种算法。

一、排序算法的稳定性

• 稳定排序算法会让原本有相等键值的纪录维持相对次序，也就是如果一个排序算法是稳定的，当有两个相等键值的纪录R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

例如，将以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在这个状况下，有可能产生两种不同的结果，一个是让相等键值的纪录维持相对的次序，而另外一个则没有：
(3, 1) (3, 7) (4, 1) (5, 6) （维持次序，稳定）
(3, 7) (3, 1) (4, 1) (5, 6) （次序被改变， 不稳定）

二、冒泡排序

• 冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，每次比较数列中相邻的两个元素，如果他们的顺序错误就把他们交换过来，直到数列排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

• 冒泡排序算法的具体运作如下：

  1. 从数列起始位置开始，比较第一个元素和第二个元素，如果第一个比第二个大（升序），就交换他们两个。
  2. 对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对。直到最大的数位于最后一个元素。
  3. 重新从第一个元素开始，重复以上步骤，直到第二大的数位于倒数第二个元素。
  4. 重复以上步骤，直到没有任何一对数字需要比较，排序完成。

• 算法实现（分步）

ali = [54, 26, 93, 22, 77, 31, 44, 55, 20]
n = len(ali)  # 9

1.比较第一个元素和第二个元素，如果第一个比第二个大（升序），就交换他们两个。

if ali[1] > ali[2]:
    ali[1], ali[2] = ali[2], ali[1]

2.利用循环对每一对相邻元素做同样的工作，i 需要到达列表的倒数第二个元素，即 列表长度-1， 因此 i 的取值为 0 —> 列表长度-2 ，因此 range(n - 1)。

for i in range(n - 1):
    if ali[i] > ali[i + 1]:
        ali[i], ali[i + 1] = ali[i + 1], ali[i]

3.重新从第一个元素开始，重复以上步骤，此时只需要比较列表的前 n-1 个元素，i 需要到达列表的倒数第三个元素，即 列表长度-1-1， 因此 i 的取值为 0 —> 列表长度-3 ，因此 range(n - 1 - 1)；再比较列表的前 n-2 个元素，i 需要到达列表的倒数第四个元素，即 列表长度-1-2， 因此 i 的取值为 0 —> 列表长度-4 ，因此 range(n - 1 - 2)。
4.重复以上步骤，直到最后，i 只需要取 0，此时为range(n - 1 - (n - 1))。

for j in range(n-1):
    for i in range(n-1-j):
        if ali[i] > ali[i+1]:
            ali[i], ali[i + 1] = ali[i+1], ali[i]

• 算法实现（整体）

# 方法1
def bubble_sort1(ali):
    n = len(ali)
    print(n)
    for j in range(n - 1):
        for i in range(n-1-j):
            if ali[i] > ali[i + 1]:
                ali[i], ali[i + 1] = ali[i + 1], ali[i]

# 方法二
def bubble_sort2(ali):
    n = len(ali)
    for j in range(n - 1, 0, -1):
        for i in range(j):
            if ali[i] > ali[i + 1]:
                ali[i], ali[i + 1] = ali[i + 1], ali[i]

# 方法二的优化
def bubble_sort3(ali):
    n = len(ali)
    for j in range(n - 1, 0, -1):
        count = 0
        for i in range(j):
            if ali[i] > ali[i + 1]:
                ali[i], ali[i + 1] = ali[i + 1], ali[i]
                count += 1
        if count == 0:
            # 若发现没有交换发生，说明已经有序，直接退出
            break

if __name__ == '__main__':
    ali = [54, 26, 93, 22, 77, 31, 44, 55, 20]
    print(ali)
    bubble_sort3(ali)
    print(ali)

• 时间复杂度
  最优时间复杂度：$O(n)$ （表示遍历一次发现没有任何可以交换的元素，排序结束。）
  最坏时间复杂度：$O(n^2)$
  稳定性：稳定