力扣刷题 | 排序（包含十大排序算法的描述、复杂度和 Python 实现）

总述

十大排序算法及分类

算法描述

• 直接选择排序：为每一个位置选择当前最小的元素。首先从第1个位置开始对全部元素进行选择，选出全部元素中最小的放在该位置，再对第2个位置进行选择，在剩余元素中选择最小的放在该位置，以此类推，重复进行“最小元素”的选择，直至完成第$n-1$个位置的元素选择，则第n个位置就只剩唯一的最大元素
• 堆排序：利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质，子结点的键值或索引总是小于（或者大于）它的父节点。首先将整个数组调整为大顶堆，调换第一个元素（最大的元素）和最后一个元素的位置，然后将从头到倒数第二个元素组成的数组调整为大顶堆，调换第一个元素（最大的元素）金额倒数第二个元素的位置，以此类推，直到堆只有一个元素
• 直接插入排序：从第二个元素开始，如果大于第一个元素，则将其插入第一个位置，然后观察第三个元素，依次检查其是否大于第二个元素和第一个元素，将其插入合适的位置，以此类推，直到插入完最后一个元素
• 希尔排序：又称为缩小增量排序，把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的元素越来越多，当增量减至 1 时，所有元素恰被分成一组
• 冒泡排序：把较小的元素往前调或者把较大的元素往后调。以较大元素向后调为例，从头至尾，依次检查当前元素和下一元素的大小，如果当前元素大于下一元素，则交换二者的位置，这种检查要进行$n$轮，第$i$轮依次检查从第一个到第$n-i$个元素
• 快速排序：设定一个基准值，通过一次循环将数组的所有元素分为两组，一组比基准值大，一组比基准值小，对两组递归调用函数完成组内的排序
• 归并排序：把序列划分为2个短序列，对短序列递归调用函数完成组内排序，再将有序的短序列进行排序为长序列
• 计数排序：空间换时间，创建一个长度为 数组最大值-数组最小值+1 的0数组，遍历数组，将0数组中索引为 对应元素-数组最小值 的位置加一，再遍历新数组，输出元素大于0的位置的索引值，即得到排序后的数组
• 桶排序：先将所有元素分入有序的桶，桶内也可以通过递归再次分桶或调用其他排序方法（如快速排序）进行排序
• 基数排序：依次根据个位数字、十位数字、百位数字等进行分桶。第一次按照个位数字排序后，将各桶合并，然后再按十位数字排序，此时相同十位数字的桶中个位小的在前面，个位大的在后面，以此类推，即得到排序后的数组。

复杂度

Python 实现

选择排序

def SelectSort(lst):
    if len(lst) <= 1:
        return lst
    
    for i in range(len(lst)):
        temp = i
        for j in range(i+1, len(lst)):
            if lst[j] < lst[temp]:
                temp = j
        lst[i], lst[temp] = lst[temp], lst[i]
            
    return lst

堆排序

def HeapSort(lst):
                    
    def heapAdjust(lst, start, end):
        temp = lst[start]
        son = 2 * start + 1
        while son <= end:
            if son < end and lst[son] < lst[son+1]:
                son += 1
            if lst[son] <= temp:
                break
            lst[start] = lst[son]
            start, son = son, 2*son+1
        lst[start] = temp
            
    
    if len(lst) <= 1:
        return lst
    
    for i in range(len(lst)//2-1, -1, -1):
        heapAdjust(lst, i, len(lst)-1)
    for i in range(len(lst)-1, 0, -1):
        lst[i], lst[0] = lst[0], lst[i]
        heapAdjust(lst, 0, i-1)

    return lst

插入排序

def InsertSort(lst):
    if len(lst) <= 1:
        return lst
    
    for i in range(1, len(lst)):
        j = i
        target = lst[i]
        while j > 0 and lst[j-1] > target:
            lst[j] = lst[j-1]
            j -= 1
        lst[j] = target
        
    return lst

希尔排序

def ShellSort(lst):
    if len(lst) <= 1:
        return lst
    
    d = len(lst)//2
    while d >= 1:
        for i in range(d, len(lst)):
            k = d
            temp = lst[i]
            while i-k >=0 and temp < lst[i-k]:
                lst[i-k+d] = lst[i-k]
                k += d
            lst[i-k+d] = temp
        d = d//2
    return lst

冒泡排序

def BubbleSort(lst):
    if len(lst) <= 1:
        return lst
    
    for i in range(len(lst)-1):
        didSwap = False
        for j in range(len(lst)-1-i):
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
                didSwap = True
        if not didSwap:
            return lst
    
    return lst

快速排序

def QuickSort(lst):
    
    def partition(lst, left, right):
        # right > left
        key = left
        i = left + 1
        while i <= right