考研复试【排序算法总结】

• 插入排序：直接插入、希尔排序
• 选择排序：简单选择排序、堆排序
• 交换排序：冒泡排序、快速排序
• 基数排序
• 归并排序

不稳定排序：快速排序、希尔排序、选择排序、堆排序。

1、直接插入排序

平均时间复杂度：O(n^2)；最好情况：O(n)；最坏情况：O(n^2)

空间复杂度：O(1)

稳定

# 1.直接插入排序
'''
将数组分成有序和无序两部分，每次将无序序列中的第一个元素插入到有序序列中的合适位置。
'''
def insertSort(L):
    for i in range(1,len(L)):       # 无序
        for j in range(i-1,-1,-1):  # 从右向左查询有序序列
            if L[j+1]<L[j]:         # 依次比较插入到合适位置
                L[j],L[j+1] = L[j+1],L[j]

2、选择排序

平均时间复杂度：O(n^2)；最好情况：O(n^2)；最坏情况：O(n^2)

空间复杂度：O(1)

不稳定

# 2.选择排序
'''
将数组分成有序和无序两部分，每次选择无序序列中的最小元素放到有序序列的末尾。
'''
def selectSort(L):
    minNum = 0      # 无序序列中的最小元素
    temp = 0
    for i in range(len(L)):
        minNum = L[i]
        for j in range(i+1,len(L)):     # 在无序序列中查找最小元素
            if L[j]<minNum:
                temp = L[j]
                L[j] = minNum
                minNum = temp
        L[i] = minNum     # 将最小元素放到有序序列的末尾

3、优化后的冒泡排序

平均时间复杂度：O(n^2)；最好情况：O(n)；最坏情况：O(n^2)

空间复杂度：O(1)

稳定

# 3.优化后的冒泡排序
'''
两两比较元素并查看是否交换，每一趟结束后都有一个元素到达最终的位置。
如果有一趟元素不需要交换，则说明数组有序，排序结束。
'''
def bubbleSort(L):
    for i in range(len(L)):
        flag = False
        for j in range(len(L)-i-1):
            if L[j]>L[j+1]:
                L[j],L[j+1] = L[j+1],L[j]   #交换
                flag = True
        if not flag:    # 没有交换，已经有序
            return L
    return L

4、归并排序

平均时间复杂度：O(nlogn)；最好情况：O(nlogn)；最坏情况：O(nlogn)

空间复杂度：O(n)

稳定

''' 
4.归并排序：分治法
    把长度为n的输入序列分成长度 n/2的子序列；
    对两个子序列分别采用归并排序；
    将两个合并好的子序列归并成最终的序列
'''
def merge(L):
    if len(L) <= 1:
        return L
    mid = len(L)//2
    left = merge(L[:mid])
    right = merge(L[mid:])
    return mergesort(left,right)

# 合并两个已排好序的数组
def mergesort(left,right):
    res = []
    i,j=0,0
    while i<len(left) and j<len(right):
        if right[j]>left[i]:
            res.append(left[i])
            i+=1
        else:
            res.append(right[j])
            j+=1
    # if j == len(right):
    #     for c in left[i:]:
    #         res.append(c)
    # else:
    #     for c in right[j:]:
    #         res.append(c)
    res += left[i:]
    res += right[j:]
    return res

5、快速排序

平均时间复杂度：O(nlogn)；最好情况：O(nlogn)；最坏情况：O(n^2)

空间复杂度：O(logn)

不稳定

# 快速排序
'''
选择一个元素作为基准，将比基准值小的元素放到基准值之前，比基准值大的元素放到基准值之后
递归的对基准值前后的两个分区进行快速排序
'''
def quickSort(L,low,high):
    if low>=high:
        return
    pivot = L[low]
    i,j=low,high
    while i < j:
        while L[j]>=pivot and i<j:
            j-=1
        L[i] = L[j]
        while L[i]<pivot and i<j:
            i+=1
        L[j] = L[i]
    # 退出循环后，i与j重合，此时所指位置为基准元素的正确位置,左边的元素都比基准元素小,右边的元素都比基准元素大
    L[i] =pivot
    quickSort(L,low,i-1)
    quickSort(L,i+1,high)
    return L

6、堆排序

平均时间复杂度：O(nlogn)

空间复杂度：O(1)

不稳定

# 6.堆排序
'''
1.将无序数组建立二叉堆，升序选择大顶堆
2.将堆顶元素与末尾元素交换
3.调整堆使其满足大顶堆，然后继续交换堆顶元素与当前末尾元素，继续调整，直到整个数组有序为止
'''
def heapsort(ls):
    # 建堆（大顶堆）从第一个非叶子结点从下至上，从右至左调整结构
    for i in range(len(ls) // 2 - 1, -1, -1):
        adjust(ls, i, len(ls))

    # 调整堆+交换
    for j in range(len(ls) - 1, 0, -1):
        # 交换堆顶元素与末尾元素，然后调整堆
        ls[j], ls[0] = ls[0], ls[j]
        adjust(ls, 0, j)


# 调整堆
def adjust(ls, i, length):
    temp = ls[i]    # 取出当前元素
    k = 2 * i + 1
    for k in range(2 * i + 1, length, 2 * k + 1):   # 从i节点的左子节点开始
        if k + 1 < length and ls[k] < ls[k + 1]:    # 如果左子节点小于右子节点，k指向较大者
            k += 1
        if ls[k] > temp:    # 如果较大的子节点大于父节点，把子节点赋值给父节点
            ls[i] = ls[k]
            i = k
        else:   # # 如果较大的子节点小于父节点，则不用调整，退出循环
            break
    ls[i] = temp    # 将当前元素temp放到合适位置