1.冒泡排序,T(n) = O(n**2)

# 冒泡排序,T(n) = O(n**2)def bubble_sort(li):    print(li)    for i in range(len(li)-1):  # i代表第几趟        for j in range(len(li) - i - 1): # j代表每趟过程中的下标            if li[j] > li[j + 1]:                li[j], li[j +1] = li[j + 1], li[j]        print(li)    return li# bubble_sort([9,8,7,6,5,4,3,2,1])

2.选择排序,T(n) = O(n**2)

# 选择排序def select_sort(li):    for i in range(len(li)-1):        min_index = i        for j in range(i, len(li)):            if li[j] < li[min_index]:                min_index = j        li[i],li[min_index] = li[min_index], li[i]    return li# print(select_sort([1,9,2,8,3,6,4,5,7]))

3.插入排序,T(n) = O(n**2)

# 插入排序,def insert_sort(li):    for i in range(1, len(li)):  # i代表每次摸到的牌的下标        tmp = li[i]        j = i - 1   # j代表手里最后一张牌的下标        while True:            if j < 0 or tmp >= li[j]:                break            li[j + 1] = li[j]            j -= 1        li[j + 1] = tmp    return li

lowbi3人组（冒泡，选择，插入），为什么说low，因为复杂度是O(n**2)

4.快速排序,T(n) = O(nlogn)

java／c++ 等内置的排序算法【17111星辰崩】

# 快速排序def quick_sort(li, left, right):    if left < right:        mid = partition(li, left, right)        quick_sort(li, left,  mid-1)        quick_sort(li, mid+1, right)def partition(data, left, right):    tmp = data[left]    while left < right:        while left < right and data[right] >= tmp:            right -= 1        data[left] = data[right] # 第一次不满足条件时，right值固定        while left < right and data[left] <= tmp:            left += 1        data[right] = data[left]    data[left]=tmp    return leftprint(quick_sort(li, 0, len(li)-1))print(li)

5.堆排序,T(n) = O(nlogn)

# 堆排序def sift(data, low, high):    """    调整函数    data: 列表    low：待调整的子树的根位置    high：待调整的子树的最后一个节点的位置    """    i = low    j = 2 * i + 1    tmp = data[i]    # i指向空位置    while j<=high:      #领导已经撸到底了        if j != high and data[j] < data[j+1]:            j += 1        #j指向数值大的孩子        if tmp < data[j]:   #如果小领导比撸下来的大领导能力值大            data[i] = data[j]            i = j            j = 2*i+1        else:            break       #撸下来的领导比候选的领导能力值大    data[i] = tmpdef heap_sort(data):    n = len(data)    # 建堆    for i in range(n//2-1, -1, -1):        sift(data, i,  n - 1)    # 挨个出数    for high in range(n - 1, -1, -1):        data[0], data[high] = data[high], data[0]        sift(data, 0, high - 1)

6.归并排序，T(n) = O(nlogn)

# 归并排序def merge(li, low, mid, high):    i = low    j = mid + 1    ltmp = []    while i <= mid and j <= high:        if li[i] <= li[j]:            ltmp.append(li[i])            i += 1        else: # li[i]>li[j]            ltmp.append(li[j])            j += 1    while i <= mid:        ltmp.append(li[i])        i += 1    while j <= high:        ltmp.append(li[j])        j += 1    li[low:high+1]=ltmpdef mergesort(li, low, high):    if low < high:        mid = (low + high) // 2        mergesort(li, low, mid)        mergesort(li, mid+1, high)        merge(li, low, mid, high)

7.希尔排序

#include 
     
        // 分类 -------------- 内部比较排序// 数据结构 ---------- 数组// 最差时间复杂度 ---- 根据步长序列的不同而不同。已知最好的为O(n(logn)^2)// 最优时间复杂度 ---- O(n)// 平均时间复杂度 ---- 根据步长序列的不同而不同。// 所需辅助空间 ------ O(1)// 稳定性 ------------ 不稳定void ShellSort(int A[], int n){    int h = 0;    while (h <= n)                          // 生成初始增量    {        h = 3 * h + 1;    }    while (h >= 1)    {        for (int i = h; i < n; i++)        {            int j = i - h;            int get = A[i];            while (j >= 0 && A[j] > get)            {                A[j + h] = A[j];                j = j - h;            }            A[j + h] = get;        }        h = (h - 1) / 3;                    // 递减增量    }}int main(){    int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 从小到大希尔排序    int n = sizeof(A) / sizeof(int);    ShellSort(A, n);    printf("希尔排序结果：");    for (int i = 0; i < n; i++)    {        printf("%d ", A[i]);    }    printf("\n");    return 0;}