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

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

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

冒泡排序（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: