十大排序算法总结

1、插入排序

遍历列表的第二个元素到最后一个元素，每次拿后面的元素与前面的元素做比较找到合适的插入位置采用一个for循环套一个while循环实现。

def generate(A):
    for j in range(1, len(A)):
        key = A[j]
        i = j - 1
        while i >= 0 and A[i] > key:  # T
            A[i + 1] = A[i]
            i = i - 1
        A[i + 1] = key
    return A

print(generate([5, 2, 4, 6, 1, 3]))

2、选择排序

首先找出最小的元素与A[0]交换，再找出第二小的元素与A[1]交换，依次类推每次找出剩下元素中最小的元素。

def generate(A):
    k = 0
    while k < len(A):
        MIN = A.index(min(A[k::]))
        A[k], A[MIN] = A[MIN], A[k]
        k += 1
    return A

3、冒泡排序

元素从左至右两两循环，将小的元素放在前面，采用双重for循环实现

"""将最大值顶到最后端"""
def bubble_sort(A):
    for i in range(len(A)-1,-1,-1):
        for j in range(i):
            if A[j] > A[j + 1]:
                A[j], A[j + 1] = A[j + 1], A[j]
    return A

"""将最小值顶到最前端"""
def bubble_sort(A):
    for i in range(len(A) - 1):
        for j in range(len(A) - 1, i, -1):
            if A[j] < A[j - 1]:
                A[j], A[j - 1] = A[j - 1], A[j]
    return A

4、归并排序

分函数将待排元素依次划分为左半部分和右半部分直到元素个数为1，然后合函数再依次合并左半部分和右半部分。

def merge(A, p, q, r):
    n_1 = q - p + 1
    n_2 = r - q
    L = [0] * (n_1 + 1)
    R = [0] * (n_2 + 1)
    for i in range(n_1):
        L[i] = A[p + i]
    for j in range(n_2):
        R[j] = A[q + 1 + j]
    L[n_1] = float("inf")
    R[n_2] = float("inf")
    i = 0
    j = 0
    for k in range(p, r + 1):
        if L[i] < R[j]:
            A[k] = L[i]
            i += 1
        else:
            A[k] = R[j]
            j += 1


def merge_sort(A, p, r):
    if p < r:
        q = (p + r) // 2
        merge_sort(A, p, q)
        merge_sort(A, q+1, r)
        merge(A, p, q, r)
    return A

5、快速排序

每次选择一个基准值，将小于基准值的元素放在基准值左边，大于基准值的元素放在基准值右边。

"""快速排序"""
def QUICK_sort(A, p, r):
    if p < r:
        q = PARTITION(A, p, r)
        QUICK_sort(A, p, q - 1)
        QUICK_sort(A, q + 1, r)
    return A


def PARTITION(A, p, r):
    key = A[r]
    i = p - 1
    for j in range(p, r):
        if A[j] <= key:
            i += 1
            A[i], A[j] = A[j], A[i]
    A[i + 1], A[r] = A[r], A[i + 1]
    return i + 1

6、堆排序

构建堆，将堆的A[0]元素依次和堆的最后一个元素交换位置，然后维护对A[0,len(A)-1]维护堆的性质，一直到。

"""堆排序,最大根"""
def PARENT(i):
    return i // 2


def LEFT(i):
    return 2 * i + 1


def Right(i):
    return 2 * i + 2


def MAX_HEAPIFY(A, i):
    l = LEFT(i)
    r = Right(i)
    if l < len(A) and A[l] > A[i]:
        largest = l
    else:
        largest = i
    if r < len(A) and A[r] > A[largest]:
        largest = r
    if largest != i:
        A[i], A[largest] = A[largest], A[i]
        MAX_HEAPIFY(A, largest)
    return A


def BUILD_HEAP(A):
    for i in range(len(A) // 2, -1, -1):
        A = MAX_HEAPIFY(A, i)
    return A


def HEAP_sort(A):
    A = BUILD_HEAP(A)
    for i in range(len(A) - 1, 0, -1):
        A[0], A[i] = A[i], A[0]
        A[0:i] = MAX_HEAPIFY(A[0:i], 0)
    return A

"""python内置函数法"""
import heapq
def HEAP_sort(A):
    h = []
    for items in A:
        heapq.heappush(h, items)
    return [heapq.heappop(h) for _ in range(len(A))]

7、计数排序

思想：对于每一个输入元素$x$, 确定小于$x$的元素的个数，利用这一信息就可以直接把$x$放到他在输出数组中的位置。

"""计数排序"""
"""适用于整数，有重复元素的情况"""
import numpy as np
def counting_sort(A):
    if len(A) < 2:
        return len(A)
    MAX = max(A)
    MIN = min(A)
    C = [0] * (MAX - MIN + 1)
    B = [0] * (len(A))
    for i in range(len(A)):
        C[A[i]] += 1
    C = np.cumsum(C)
    for i in range(len(A) - 1, -1, -1):
        B[C[A[i]]-1] = A[i]
        C[A[i]] -= 1
    return B

8、基数排序

依次按照从最低有效位到最高有效位进行排序（排序方法选择计数排序）。

"""基数排序"""
"""适用于整数，有重复元素"""
def Radix_sort(A):
    n = len(str(max(A)))  # 获取最大元素的位数
    for k in range(n):
        bucket_list = [[] for i in range(10)]
        for i in A:
            bucket_list[i // (10 ** k) % 10].append(i)
        A = []
        for i in bucket_list:
            for j in i:
                A.append(j)
    return A

9、桶排序

将元素划分到若干个桶里，然后对每个桶的元素进行排序（采用插入排序即可）。

"""桶排序"""
def Insertion_sort(A):
    if len(A) < 2:
        return A
    for i in range(1, len(A)):
        key = A[i]
        j = i - 1
        while j >= 0 and A[j] > key:
            A[j + 1] = A[j]
            j -= 1
        A[j + 1] = key
    return A


def Bucket_sort(A):
    n = len(A)
    Bucket = [[] for i in range(n)]
    for i in range(n):
        Bucket[int(n * A[i])].append(A[i])
    RES = []
    for j in Bucket:
        if j:
            j = Insertion_sort(j)
            for num in range(len(j)):
                RES.append(j[num])
    return RES

10、希尔排序