排序算法（Python实现）

目录

1. 快速排序

2. 冒泡排序 （稳定）

3. 选择排序

4. 插入排序（稳定）

---

• 稳定的排序：冒泡排序、插入排序、归并排序
• 不稳定的排序：希尔排序、选择排序、堆排序、快速排序等

排序方法	稳定性	平均时间复杂度	最坏情况	最好情况	空间复杂度
冒泡排序	稳定	n^2	n^2	n	1
选择排序	不稳定	n^2	n^2	n^2	1
插入排序	稳定	n^2	n^2	n	1
快速排序	不稳定	n·logn	n^2	n·logn	n·logn
希尔排序	不稳定	n^1.3	n^2	n	1
堆排序	不稳定	n·logn	n·logn	n·logn	1
归并排序	稳定	n·logn	n·logn	n·logn	n
计数排序	稳定	n+k	n+k	n+k	n+k
桶排序	稳定	n+k	n^2	n	n+k
基数排序	稳定	n*k	n*k	n*k	n+k

• 交换排序：冒泡排序、快速排序
• 插入排序：简单插入排序、希尔排序
• 选择排序：简单选择排序、堆排序
• 归并排序：二路归并排序、多路归并排序

1. 快速排序

• 是一种分治思想（挖坑法/填坑法）。挑一个元素作为基准pivot，将所有比基准小的值摆在左侧，大的值摆在右侧，即分区partition
• 递归调用该方法完成所有排序。（左右分别找到大于或小于pivot的数，进行交换）

def partition(ls,l,r):
    tmp = ls[l]
    while l<r:
        while l<r and ls[r] >= tmp:
            r -= 1
        ls[l] = ls[r]
        while l<r and ls[l] <= tmp:
            l += 1
        ls[r] = ls[l]
    ls[l] = tmp
    return l

def quick_sort(ls,l,r):
    if l>=r: return
    pivot = partition(ls, l, r)
    quick_sort(ls, l, pivot-1)
    quick_sort(ls, pivot+1, r)
#—————————— E N D —————— E N D ——————————
# 简单写法
def partition2(ls,l,r):
    i = l-1
    for j in range(l,r):
        if ls[j]<=ls[r]:
            i += 1
            ls[i],ls[j] = ls[j], ls[i]
    ls[r], ls[i+1] = ls[i+1], ls[r]
    return i
    
def quick_sort2(ls,l,r):
    if l>=r: return
    pivot = partition2(ls,l,r)
    quick_sort(ls, l, pivot)
    quick_sort(ls, pivot+1, r)

2. 冒泡排序 （稳定）

• 重复遍历列表，每一次遍历确定最后一位最大的数。
• 在遍历的过程中，依次比较相邻的元素。

def bubble_sort(ls):
    for i in range(len(ls)-1):
        for j in range(len(ls)-i-1):
            if ls[j] > ls[j+1]:
                ls[j], ls[j+1] = ls[j+1], ls[j]
    return ls

3. 选择排序

• 在列表里找到最小的元素，依次往后填放

def selection_sort(ls):
    for i in range(len(ls)-1):
        min = i
        for j in range(i+1,len(ls)):
            if ls[j] < ls[min]:
                min = j
        ls[i], ls[min] = ls[min], ls[i]
    return ls

4. 插入排序（稳定）

• 以第一个元素为基准（把第一个元素当作拍好的序列）
• 从第二个元素起，从当前元素向前扫描已排序的元素，不断交换，直到找到小于等于自己的元素，插到该元素后面。

def insertion_sort(ls):
    for i in range(1,len(ls)):
        now = i
        for j in range(i-1,-1,-1):
            if ls[j] > ls[now]:
                ls[j], ls[now] = ls[now], ls[j]
                now = j
            else:
                break
    return ls