十大排序算法介绍及python实现

排序算法

排序算法简单的分为两类：比较排序和非比较排序，其中比较排序是通过比较元素的相对大小来实现排序，其复杂度的上限为$O(nlogn)$，所以也称其为非线性时间排序；非比较排序不是通过比较元素相对大小来实现，通常能够以$O(n)$的复杂度来实现，所以也称其为线性时间排序，下面给出了十种排序算法的复杂度（时间复杂度和空间复杂度）和稳定性

排序算法	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
冒泡排序	$O(n^2)$	$O(n^2)$	$O(n)$	$O(1)$	稳定
选择排序	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O(1)$	不稳定
插入排序	$O(n^2)$	$O(n^2)$	$O(n)$	$O(1)$	稳定
希尔排序	$O(n^{1.3})$	$O(n^2)$	$O(n)$	$O(1)$	不稳定
归并排序	$O(nlogn)$	$O(nlogn)$	$O(nlogn)$	$O(n)$	稳定
堆排序	$O(nlogn)$	$O(n^2)$	$O(nlogn)$	$O(1)$	不稳定
快速排序	$O(nlogn)$	$O(n^2)$	$O(nlogn)$	$O(nlogn)$	不稳定
计数排序	$O(n+k)$	$O(n+k)$	$O(n+k)$	$O(n+k)$	稳定
桶排序	$O(n+k)$	$O(n)$	$O(n)$	$O(n+k)$	稳定
基数排序	$O(n\ast k)$	$O(n\ast k)$	$O(n\ast k)$	$O(n+k)$	稳定

其中，$n$表示需要排序的元素数量，$k$表示桶的数量

LB三人组

冒泡排序

冒泡排序的思想就是每次循环过程中，大的元素下降，小的元素上升，从而进行排序，具体过程如下：

代码如下：

def bubble_sort(a):
    n = len(a)
    flag = False   #设置标志位，避免无效排序
    for i in range(n-1, 0, -1):
        for j in range(i):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
                flag = True
        if not flag:
            break
    return a


if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(bubble_sort(a))

选择排序

选择排序的思想就是每次循环的过程中找到最小的值放在第一位，依次循环找到其他较小的值放在接下来的位置，通过查找进行排序，其过程如下：

代码如下：

def select_sort(a):
    n = len(a)
    for i in range(n - 1):
        min_index = i
        for j in range(i+1, n):
            if a[j] < a[min_index]:
                min_index = j
        a[i], a[min_index] = a[min_index], a[i]
    return a
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(select_sort(a))

插入排序

插入排序的思想就是和之前的元素进行比较，大的元素放在后面，小的元素放在前面，具体过程如下：

代码如下：

def insert_sort(a):
    n = len(a)
    for i in range(1, n):
        cur_val = a[i]
        pos = i
        while pos > 0 and a[pos - 1] > cur_val:
            a[pos] = a[pos - 1]
            pos -= 1
        a[pos] = cur_val
    return a
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(insert_sort(a))

希尔排序

希尔排序是插入排序的另一种变化，通过有间隔的插入排序并逐步减小间隔实现最终的排序，其过程如下：

代码如下：

def shell_sort(a):
    n = len(a)
    gap = n // 2
    while gap > 0:
        for i in range(gap):
            gap_insert(a, i, gap)   #有间隔的插入排序
        gap //= 2
    return a
def gap_insert(a, sta, gap):
    for i in range(sta + gap, len(a), gap):
        cur_val = a[i]
        pos = i
        while pos > sta and a[pos - gap] > cur_val:
            a[pos] = a[pos - gap]
            pos -= gap
        a[pos] = cur_val
    return a
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(shell_sort(a))

NB三人组

归并排序

归并排序是基于分治的思想，将需要排序的数据分为两个子序列，对子序列进行排序，然后将排好序的子序列进行合并实现最终的排序，过程如下：

代码如下：

def merge_sort(a):
    if len(a) <= 1:
        return a
    n = len(a) // 2
    left = merge_sort(a[:n])    #子序列归并排序
    right = merge_sort(a[n:])   
    return merge(left, right)   #合并排好序的子序列
def merge(left, right):
    l, r = 0, 0
    res = []
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            res.append(left[l])
            l += 1
        else:
            res.append(right[r])
            r += 1
    res.extend(left[l:])
    res.extend(right[r:])
    return res
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(merge_sort(a))

堆排序

堆排序思想是建立一个大根堆，将堆顶位置与最后一个进行交换，再建立大根堆，重复上述操作实现排序，过程如下：

代码如下：

def heap_sort(a):
    n = len(a)
    for i in range(n // 2 - 1, -1, -1):
        siftdown(a, i, n - 1)          #建立大根堆
    for j in range(n - 1, 0, -1):
        a[0], a[j] = a[j], a[0]        #交换后，继续建立大根堆
        siftdown(a, 0, j-1)
    return a
def siftdown(a, sta, end):
    root = sta                  #根节点
    while True:
        child = 2 * root + 1    #左孩子节点
        if child > end:
            break
        if child + 1 <= end and a[child] < a[child + 1]:   #存在右孩子节点
            child += 1
        if a[root] < a[child]:                      #维护大根堆
            a[root], a[child] = a[child], a[root]
            root = child
        else:
            break
    return a
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(heap_sort(a))

快速排序

快速排序的思想是选择一个基准线，将比基准线小的放在一边，比基准线大的放在另一边，通过对两部分进行排序实现最终的排序，过程如下：

代码如下：

def quick_sort(a):
    if len(a) <= 1:
        return a
    left = []
    right = []
    base = a.pop()
    for x in a:
        if x < base:
            left.append(x)
        else:
            right.append(x)
    return quick_sort(left) + [base] + quick_sort(right)
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(quick_sort(a))

线性时间排序

计数排序

计数排序的思想是建立计数器，统计每个数字出现的次数，再将统计的结果输出实现最终的排序，过程如下：

代码如下：

def count_sort(a):
    n = len(a)
    max_val = max(a)
    count = [0] * (max_val + 1)
    for i in range(n):
        count[a[i]] += 1
    res = []
    for i in range(max_val + 1):
        for j in range(count[i]):
            res.append(i)
    return res
            
            

if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(count_sort(a))

桶排序

桶排序的思想就是将对应范围内的元素放进桶中，对桶中的元素进行排序，然后再将元素按照顺序取出，完成最终的排序，过程如下：

代码如下：

def bucket_sort(a,n=100,max_num=10000):
    buckets = [[] for _ in range(n)]   #创建桶
    for x in a:
        i = min(x // (max_num // n) , n - 1)    
        buckets[i].append(x)           #将对应的数据放进桶中
        for j in range(len(buckets[i]) - 1 , 0 ,-1):
            if buckets[i][j] < buckets[i][j - 1]:
                buckets[i][j] , buckets[i][j - 1] = buckets[i][j - 1] , buckets[i][j]
            else:
                break
    result = []
    for bin in buckets:
        result.extend(bin)
    return result


if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(bucket_sort(a))

基数排序

基数排序的思想就是将整数按位分为不同的数字，对每个数字进行比较，具体过程如下：

代码如下：

def radix_sort(a):
    max_val = max(a)
    it = 0
    while 10 ** it <= max_val:
        buckets = [[] for _ in range(10)]
        for x in a:
            i = (x // (10 ** it)) % 10
            buckets[i].append(x)
        a = [j for i in buckets for j in i]
        it += 1
    return a


if __name__ == "__main__":
    a = [90, 5, 83, 42, 12, 15]
    print(radix_sort(a))

参考文献：
[1]十大经典排序算法（动图演示）
[2]动画:一篇文章快速学会桶排序