十大排序算法（Python实现）

前言

手撕算法，面试必备，你懂得！

一、排序及其分类

所谓排序就是将一组无序的记录序列调整为有序的记录序列。

① 选择排序：主要包括简单选择排序和堆排序；
② 插入排序：简单插入排序、希尔排序；
③ 交换排序：冒泡排序、快速排序；
④ 归并排序
⑤ 非比较排序：计数排序、桶排序、基数排序属于非比较排序，算法时间复杂度O(n)， 属于空间换时间。

二、经典排序算法的实现

2.1 选择排序

从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

实现的代码如下：

def select_sort(li):
    n = len(li)
    for i in range(n):
        for j in range(i,n):
            if li[i]<li[j]:
                li[i], li[j] = li[j], li[i]
    return li

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
print(select_sort(li))

# 输出结果为：[102, 98, 92, 91, 86, 75, 49, 33, 27, 11]

2.2 插入排序

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。算法适用于少量数据的排序，时间复杂度为$O(n^2)$。

实现步骤如下：

① 以数组中第一个元素为基准；
② 取出已排序序列的下一个数，当前这个数是需要被排序的。用当前这个数与已排序序列从右往左进行比较；
③ 如果当前未排序的数比已排序序列中的元素小，则将已排序序列中的这个元素往右挪一个位置，空出当前位置，继续向左判断；
④ 重复步骤③，直到未排序的数大于已排序序列中的元素，将未排序的数插入到空出的位置；
⑤ 重复② - ⑤步，直到所有数据元素都已被安排妥当。

如下图所示：

实现的代码如下：

def insert_sort(li):
    for i in range(1, len(li)):
        for j in range(i, 0, -1):
            if li[j] < li[j-1]:
                li[j], li[j-1] = li[j-1], li[j]

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
insert_sort(li)
print(li)

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.3 希尔排序

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。克服了插入排序每次只比较相邻元素的缺陷。

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

实现过程如下图：

实现的代码如下：

def shell_sort(alist):
    n = len(alist)
    # 初始步长
    gap = n // 2
    while gap > 0:
        # 按步长进行插入排序
        for i in range(gap, n):
            j = i
            # 插入排序
            while j>=gap and alist[j-gap] > alist[j]:
                alist[j-gap], alist[j] = alist[j], alist[j-gap]
                j -= gap
        # 得到新的步长
        gap = gap // 2

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
shell_sort(li)
print(li)

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.4 冒泡排序

详见本人的另外一篇博客：关于冒泡排序及其优化（Python实现）。

2.5 归并排序

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

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

实现过程如下图所示：

代码实现如下：

def merge_sort(alist):
    if len(alist) <= 1:
        return alist
  
    num = len(alist)// 2
    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])

    return merge(left,right)

def merge(left, right):
    l, r = 0, 0
    result = []
    while l<len(left) and r<len(right):
        if left[l] <= right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
print(merge_sort(li))

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.6 堆排序

详见本人的另外一篇博客：算法之堆排序（python实现）。

2.7 快速排序

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

详细步骤为：

① 从数列中挑出一个元素，称为"基准"；
② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以放到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个被称为分区操作。
③ 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

过程如下图：

代码实现如下：

def quick_sort(alist, start, end):
    """快速排序"""
    if start >= end:
        return

    mid = alist[start]
    low = start
    high = end

    while low < high:
        while low < high and alist[high] >= mid:
            high -= 1
        alist[low] = alist[high]

        while low < high and alist[low] < mid:
            low += 1
        alist[high] = alist[low]

    alist[low] = mid

    quick_sort(alist, start, low-1)
    quick_sort(alist, low+1, end)

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
quick_sort(li, 0, len(li)-1)
print(li)

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.8 计数排序

基本思想： 对于数组 A 中的每一个元素 A[i] ，确定小于 A[i] 的元素总个数。所以直接可以把 A[i] 放到输出数组的相应位置上，比如数组 A 中有 5 个数小于 A[i] ，则 A[i] 应该放在输出数组的第六个位置上。

代码实现为：

def count_sort(alist): 
    n = len(alist)  
    k = max(alist)  
    b = [0 for i in range(n)]  
    c = [0 for i in range(k + 1)]  
    for j in alist:
        c[j] = c[j] + 1
    for i in range(1, len(c)):
        c[i] = c[i] + c[i-1]
    for j in alist:
        b[c[j] - 1], c[j] = j, c[j] - 1

    return b

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
print(count_sort(li))

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.9 桶排序

基本思想： 把数组 A 划分为n个大小相同的区间（即桶），每个子区间各自排序，最后合并。桶排序要求数据的分布必须均匀，否则可能会失效。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

代码实现为：

def bucket_sort(alist):
    buckets = [0] * ((max(alist) - min(alist)) + 1)  
    for i in range(len(alist)):
        buckets[alist[i] - min(alist)] += 1  
    b = []
    for i in range(len(buckets)):
        if buckets[i] != 0:
            b += [i + min(alist)] * buckets[i]
    return b

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
print(bucket_sort(li))

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

2.10 基数排序

基本思想： 将待排序的数据按照位数切割成不同的数字，然后按每个位数分别比较。

基数排序可以采用两种方式：

① LSD（Least Significant Digital）：从待排序元素的最右边开始计算（如果是数字类型，即从最低位个位开始）。
② MSD（Most Significant Digital）：从待排序元素的最左边开始计算（如果是数字类型，即从最高位开始）。

代码实现为：

import math

def radix_sort(a, radix=10):
    """a为整数列表， radix为基数"""
    K = int(math.ceil(math.log(max(a), radix))) 
    bucket = [[] for i in range(radix)]
    for i in range(1, K+1): 
        for val in a:
            bucket[val%(radix**i)//(radix**(i-1))].append(val) 
        del a[:]
        for each in bucket:
            a.extend(each) 
        bucket = [[] for i in range(radix)] 

输入随机案例进行验证：

li = [92, 75, 86, 33, 91, 102, 27, 98, 11, 49]
radix_sort(li)
print(li)

# 输出的结果为：[11, 27, 33, 49, 75, 86, 91, 92, 98, 102]

三、排序算法的比较