Python数据结构应用5——排序（Sorting）

在具体算法之前，首先来看一下排序算法衡量的标准：

1. 比较：比较两个数的大小的次数所花费的时间。
2. 交换：当发现某个数不在适当的位置时，将其交换到合适位置花费的时间。

冒泡排序（Bubble Sort）

这是一个面试经常考的排序，虽然简单，但是要保证一点都不出错也不简单。

冒泡，顾名思义，每一次冒出一个泡泡出来，这个泡泡是剩余数中最大的那个数。所以，如果有n个数待排序，那么需要冒(n-1)次泡泡。即最外层循环需要len(list)-1次。

每一次冒泡的过程即内层循环。每次取一对数（pair），按顺序从最开始的一对数开始，比较两个数哪个数比较大就交换到上部（右边/冒泡），然后依次执行下一对数（每次进1），这个内层循环的次数随着外层循环的次数增加而减少，因为一旦进行了一次外层循环，已经排好序的数就多了一个。

一次冒泡的过程如下图：

def bubble_sort(a_list):
    for pass_num in range(len(a_list)-1,0,-1):
        for i in range(pass_num):
            if a_list[i] > a_list[i+1]:
                a_list[i],a_list[i+1] = a_list[i+1],a_list[i]
a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
bubble_sort(a_list)
print(a_list)

[17, 20, 26, 31, 44, 54, 55, 77, 93]

这种冒泡排序是很耗时间的，每一次外层循环，需要比较的次数如下图所示：

所以，一共需要(frac{1}{2}n^{2}-frac{1}{2}n) 次比较，时间复杂度是(O(n^{2}))，如果看最坏的情况，即每次比较后都需要交换两个数，那么总时间✖️2

事实上，在很多情况下，冒泡排序并不需要完成所有的外循环就已经将所有数排好序啦，但是由于程序的笨蛋性，他还是在一直的执行下去，浪费时间。那么，我们可以将冒泡排序进行改进，让其知道一旦所有数据已经是按顺序排好时就停止工作，以进行时间优化：

def short_bubble_sort(a_list):
    exchanges = True   # 此标志用来记录一轮循环中是否进行了交换
    pass_num = len(a_list)-1
    while pass_num > 0 and exchanges:
        exchanges = False
        for i in range(pass_num):
            if a_list[i]>a_list[i+1]:
                exchanges = True
                a_list[i],a_list[i+1] = a_list[i+1],a_list[i]
            pass_num -= 1
a_list=[20, 30, 40, 90, 50, 60, 70, 80, 100, 110]
short_bubble_sort(a_list)
print(a_list)

[20, 30, 40, 50, 60, 70, 80, 90, 100, 110]

选择排序（Selection Sort）

选择排序其实每次外层循环的结果和冒泡排序很像，即每次在待排序元素中找到最大的元素，将其与应该放的位置交换。即每进行一次外层循环就多排好了一个元素。

选择排序的时间复杂度仍为(O(n^{2}))，但是由于其元素交换的次数比冒泡排序要少，所以消耗的时间比冒泡排序要短。

def selection_sort(a_list):
    for fill_slot in range(len(a_list)-1,0,-1):
        # fill_slot 这一轮最大元素将要放入的位置
        pos_of_max=0
        # 这一轮最大元素的位置
        for location in range(1, fill_slot+1):
            if a_list[location]>a_list[pos_of_max]:
                pos_of_max = location
        a_list[fill_slot],a_list[pos_of_max]=a_list[pos_of_max],a_list[fill_slot]
a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
selection_sort(a_list)
print(a_list)   

[17, 20, 26, 31, 44, 54, 55, 77, 93]

插入排序（Insertion Sort）

插入排序就像插扑克牌，每一次插一张牌到合适大小的位置，直到n张牌插入完毕。所以插入排序需要n-1次插入操作，即外层循环。每一次插入操作需要在已经排好序的数中依次进行比较，直到找到合适的位置。所以插入排序的时间复杂度在最好的情况下为(O(n))，最坏情况下为(O(n^{2}))。

插入排序过程如下图所示：

def insertion_sort(a_list):
    for index in range(1, len(a_list)):
        # index 为该轮要插入元素的位置
        current_value = a_list[index]
        position = index   
        while position>0 and a_list[position-1]>current_value:
                a_list[position] = a_list[position-1]
                position = position - 1
        a_list[position] = current_value
a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
insertion_sort(a_list)
print(a_list)

[17, 20, 26, 31, 44, 54, 55, 77, 93]

希尔排序（Shell Sort）

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率，但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

如下图所示，这个list中一共有9个数，我们将这9个数分成三个sublists，位置增量为3（如图每一列的深色部分为一个sublist）。对于每个sublist进行一次插入排序，且保持原来的位置放置在一个新的list中。

对于这个新的list，我们进行一次标准的插入排序。注意到，由于我们对于之前的sublist已经进行过排序，所以我们减少了这次标准插入排序的移动操作数。

def shell_sort(a_list):
    increment = len(a_list) // 2  # （步进数）
    while increment > 0:
        for start_position in range(increment):
            gap_insertion_sort(a_list, start_position, increment)
        print("After increments of size", increment, "The list is",a_list)
        increment = increment // 2
        
def gap_insertion_sort(a_list, start, gap):
    for i in range(start+gap, len(a_list), gap):
        # 以下为插入排序
        current_value = a_list[i]
        position = i
        while position >= gap and a_list[position-gap]>current_value:
            a_list[position] = a_list[position-gap]
            position = position - gap
            a_list[position] = current_value
        
a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
shell_sort(a_list)
print(a_list)

After increments of size 4 The list is [20, 26, 44, 17, 54, 31, 93, 55, 77]
After increments of size 2 The list is [20, 17, 44, 26, 54, 31, 77, 55, 93]
After increments of size 1 The list is [17, 20, 26, 31, 44, 54, 55, 77, 93]
[17, 20, 26, 31, 44, 54, 55, 77, 93]

步进increment在希尔排序中是一个重要的参数。上列函数shell_sort()使用了不同的步进。首先，创造了n/2个sublist，接下来，创造了n/4个sublist，步进也逐次减小。下图是第一次循环中的sublist选择：

归并排序（Merge Sort）

从这里，开始介绍分治策略（divide and conquer）。

归并排序其实跟二分搜索很相像，采用的是递归的方法。每次将待排序的list'平均'分成左右两个sublists，然后分别进行排序，依次递归，直到sublist的长度<=1。

第一个图是list的divide的过程：

第二个图是sublists的conquer(merge)的过程：

def merge_sort(a_list):
    print('splitting', a_list)
    if len(a_list)>1:
        mid = len(a_list) // 2
        # 这两个half需要额外的空间
        left_half = a_list[:mid]
        right_half = a_list[mid:]
        merge_sort(left_half)
        merge_sort(right_half)
        # 当左右两个sublist都排好序时，每次选择两个sublist的最小的数
        # 然后在这两数中选择更小的数依次放入待返回的list中
        i,j,k=0,0,0
        while i<len(left_half) and j<len(right_half):
            if left_half[i] < right_half[j]:
                a_list[k] = left_half[i]
                i = i + 1
            else:
                a_list[k] = right_half[j]
                j = j + 1
            k = k + 1
        while i < len(left_half): 
            a_list[k] = left_half[i] 
            i = i + 1
            k = k + 1
        while j < len(right_half): 
            a_list[k] = right_half[j] 
            j = j + 1 
            k = k + 1
        print("Merging ", a_list)
        
a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
merge_sort(a_list)
print(a_list)      

splitting [54, 26, 93, 17, 77, 31, 44, 55, 20]
splitting [54, 26, 93, 17]
splitting [54, 26]
splitting [54]
splitting [26]
Merging  [26, 54]
splitting [93, 17]
splitting [93]
splitting [17]
Merging  [17, 93]
Merging  [17, 26, 54, 93]
splitting [77, 31, 44, 55, 20]
splitting [77, 31]
splitting [77]
splitting [31]
Merging  [31, 77]
splitting [44, 55, 20]
splitting [44]
splitting [55, 20]
splitting [55]
splitting [20]
Merging  [20, 55]
Merging  [20, 44, 55]
Merging  [20, 31, 44, 55, 77]
Merging  [17, 20, 26, 31, 44, 54, 55, 77, 93]
[17, 20, 26, 31, 44, 54, 55, 77, 93]

归并排序的时间复杂度，又是时候祭出这张图了（来自《算法导论》）。来看这个图，对于每一个conquer（merge）过程，merge后进行排序的时间消耗为len(sublist)，在图中体现为n, n/2, n/4, ...。所以，图中每一行消耗的总时间为 n/len(sublist) * len(sublist)，其中n为list的总长度。而一共有log(n)个这样的行，所以归并排序的时间复杂度为(O(nlog(n)))

快速排序

快速排序也是一种分治策略，相对于归并排序来说，快速排序没有使用额外的空间。

快速排序会在list中选择一个主元（pivot value），也可以叫它分割点（split point），通常是list的首尾元素，如下图，主元是54。接下来，在除去主元的剩余数中最左边为左标记（leftmark），最右边为右标记（rightmark），左标记向右移，直到移到的数小于主元数为止；右标记向左移，直到移到的数大于主元数为止。然后，交换此时两个标记的数。这个过程一直进行下去，直到两个标记移动交叉（cross）则停止移动。

此时，将主元数插入到左标记和右标记之间，则主元左边的数全都小于主元，主元右边的数全都大于主元。

对左右两边的数构成的sublist进行递归quicksort。整个过程如下图：

def quick_sort(a_list):
    quick_sort_helper(a_list, 0, len(a_list) - 1)
def quick_sort_helper(a_list, first, last):
    # first和last分别是a_list的首尾位置，由于快速排序没有额外空间，
    # 所以需要记录sublist的首尾位置
    if first < last: # 若len(sublist)>0
        split_point = partition(a_list, first, last)
        quick_sort_helper(a_list, first, split_point - 1)
        quick_sort_helper(a_list, split_point + 1, last)
def partition(a_list, first, last):
    pivot_value = a_list[first]
    left_mark = first+1
    right_mark = last
    done = False
    while not done:
        # 
        while left_mark <= right_mark and a_list[left_mark] <= pivot_value:
            left_mark = left_mark + 1
        while left_mark <= right_mark and a_list[right_mark] >= pivot_value:
            right_mark = right_mark - 1
        if right_mark < left_mark:
            done = True
        else: # (right_mark - left_mark) == 1
            a_list[left_mark],a_list[right_mark]=a_list[right_mark],a_list[left_mark]
    a_list[first],a_list[right_mark] = a_list[right_mark],a_list[first]
    return right_mark

a_list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
quick_sort(a_list)
print(a_list)

[17, 20, 26, 31, 44, 54, 55, 77, 93]

快速排序的时间复杂度取决于主元的选择，如果主元的大小每次都在整个list的中间，那么divide的过程则就类似于归并排序的过程，时间复杂度的结果就是(O(nlog(n)))。

然而，并不是所有情况都是这么好的。想象一下最坏情况，如果每次主元都正好选到了剩余list中最小或者最大的那个数，则每次divide只能分割掉一个元素，这就和选择排序基本无异了，时间复杂度上升为(O(n^{2}))

所以，为了避免这种情况的发生，我们可以尝试随机选择主元，这可以减少原始数据的本来结构对于复杂度的影响。

• Reference:

1. Problem Solving with Algorithms and Data Structures, Release 3.0
2. 希尔排序-Wikipedia