【数据结构与算法】三 排序

定义：算法（algorithm），在数学（算学）和计算机科学之中，为任何一系列良定义的具体计算步骤，常用于计算、数据处理和自动推理。作为一个有效方法，算法被用于计算函数，它包含了一系列定义清晰的指令，并可于有限的时间及空间内清楚的表述出来。

参考动画：https://www.webhek.com/post/comparison-sort/

排序算法的稳定性：

稳定性：稳定排序算法会让原本有相等键值的记录维持相对次序。也就是如果一个排序算法是稳定的，当有两个相等键值的记录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）    # 次序被改变

不稳定排序算法可能会在相等的键值中改变记录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地实现为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较。（比如上面的比较中加入第二个标准：第二个键值的大小）就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。

3.1 冒泡排序

冒泡排序（英语：bubble sort）是一种简单的排序算法，它重复地遍历要排序的数列。一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢”浮“到数列的顶端。

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

• 比较相邻的元素，如果第一个比第二个大（升序），就交换他们两个

• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

• 针对所有的元素重复以上的步骤，除了最后一个

• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

冒泡排序的分析

交换过程图示（第一次）：

那么我们需要进行n-1次冒泡过程，每次对应的比较次数如下图所示：

arr = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print('arr:', arr)
n = len(arr)
# 多少轮
for j in range(n - 1):
    for i in range(0, n-1-j):
        if arr[i] > array[i+1]：
            arr[i],arr[i+1] = arr[i+1],arr[i]

print('arr:',arr)

3.2 选择排序

选择排序（selection sort）是一种简单直观的排序算法。它的工作原理如下，首先在末排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾，以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

选择排序分析

排序过程

arr = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print('arr:\t', arr)
n = len(arr)
for j in range(n-1):
    min_index = j    # 记录最小值的位置
    # 遍历所有元素，获取最小值的位置
    for i in range(j+1, n):
        if arr[i] < arr[min_index]:
            # 更新最小值的位置
            min_index = i
    if min_index =/= j:
        arr[j],arr[min_index] = arr[min_index], arr[j]
    
print('arr:\t', arr)

3.3 插入排序

插入排序（英语：Insertion Sort）是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

插入排序分析

arr = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print('arr:\t', arr)

n = len(arr)
for j in range(1, n):
    # j = [1,2,3....,n-1]
    # j = 5  i = [5,4,3,2,1,0]
    for i in range(j, 0, -1):
        if arr[i] <= arr[i-1]:
            arr[i], arr[i-1] = arr[i-1], arr[i]
        else:
            break

print('arr:\t', arr)
    

3.4 快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition - exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序数列。

步骤为：

1、从数列中挑出一个元素，称为‘基准’（pivot）

2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面 （相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了，虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

def quick_sort(arr, start, end):
    """快速排序"""
    
    # 递归的退出条件
    if start >= end:
        return
        
    # 设定起始元素为要寻找位置的基准元素
    mid = arr[start]
    
    # left为序列左边的由左向右移动的游标
    left = start
    
    # right为序列右边的由右向左移动的游标
    right = end
    
    while left < right:
        # 如果left与right未重合，right指向的元素不比基准元素小，则right向左移动
        while left < right and arr[right] >= mid:
            right -= 1
        
        # 将right指向的元素放到left的位置上
        arr[left] = arr[right]
        
        # 如果left与right未重合，left指向的元素比基准元素小，则left
        while left < right and arr[left] < mid:
            left += 1
        
        # 将left指向的元素放到right的位置上
            arr[right] = arr[left]
    
    # 退出循环后，left与right重合，此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    arr[left] = mid
    
    
    # 对基准元素左边的子序列进行快速排序
    quick_sort(arr, start, left - 1)
    
     # 对基准元素右边的子序列进行快速排序
    quick_sort(arr,left + 1, end)
    

arr = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print('arr:\t', arr)
quick_sort(arr, 0, len(arr)-1)
print('arr:\t', arr)

3.5 希尔排序

希尔排序（Shell Sort）是插入排序的一种，也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法，该方法因DL.Shell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序过程

希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了，将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

例如，假设由这样一组数[13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]， 如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样（竖着的元素是步长组成）：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45]。这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59 
94 65 82
45

排序之后变为

10 14 13
25 23 33
27 25 59
39 65 73 
45 94 82
94

最后以1步长进行排序（此时就是简单的插入排序了）

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

n = len(arr)
gap = n//2
print('gap:\t',gap)
while gap >= 1:
    # 插入排序算法
    for j in range(gap, n):
        # j - [gap, gap + 1, ... ,n-1]
        # 处理元素向前遍历插入到相应的位置上
        i = j
        # 处理希尔分组里面的数据，如果当前索引减去分组数量大于0，就表示有前一个数据
        while（i - gap）>= 0:
            # 如果当前数据小于之前的数据，就进行交换，并且计算下一个
            if arr[i] < arr[i-gap]:
                arr[i],arr[i-gap] = arr[i -gap], arr[i]
                i -= gap
            else:
                break
    # 缩短gap间隔
    gap //= 2
    print('gap:\t',gap)
    
print(arr)

3.6 归并排序

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

归并排序的分析

def merge_sort(arr):
    """归并排序"""
    n = len(arr)
    if 1 == n:
        return arr
    mid = n//2
    
    # 对左半部分进行归并排序
    left_arr = merge_sort(arr[:mid])
    
    # 对右半部分进行归并排序
    right_arr = merge_sort(arr[mid:])
    
    # 合并两个有序集合
    left, right = 0,0
    new_arr = []
    
    left_n = len(left_arr)
    right_n = len(right_arr)
    
    while left < left_n and right < right_n:
        if left_arr[left] <= right_arr[right]:
            new_arr.append(left_arr[left])
            left += 1
        else:
            new_arr.append(right_arr[right])
            right += 1
        
    new_arr += left_arr[left:]
    new_arr += right_arr[right:]
    
    return new_arr
    
arr = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print('排序之前：\t',arr)
sorted_arr = merge_sort(arr)
print('排序之后：\t',sorted_arr)