千奇百怪的排序算法

1. 快速排序

采用左闭右闭的写法

参考视频：清华大学博士讲解Python数据结构与算法（完整版）全套100节

def partition(dataset,left,right):
    temp = dataset[left]
    while left < right:
        while left < right and temp <= dataset[right]:
            right -= 1
        dataset[left] = dataset[right]
        while left < right and temp > dataset[left]:
            left += 1
        dataset[right] = dataset[left]
    dataset[left] = temp
    return left

def quick_sort(dataset,left,right):
    if left < right:
        mid = partition(dataset,left,right)
        quick_sort(dataset,left,mid-1)
        quick_sort(dataset,mid+1,right)
        
if __name__ == '__main__':
    dataset = [1, 534, 213, 1543, 123, 5456, 21]
    quick_sort(dataset,0,len(dataset)-1)
    print(dataset)

2. 归并排序

def merge_bisides(dataset,low,mid, high): # 注意这里的 mid
    i = low
    j = mid + 1
    ltemp = []
    while i <= mid and j <= high:
        if dataset[i] < dataset[j]:
            ltemp.append(dataset[i])
            i += 1
        else:
            ltemp.append(dataset[j])
            j += 1
    while i <= mid:
        ltemp.append(dataset[i])
        i += 1
    while j <= high:
        ltemp.append(dataset[j])
        j += 1
    dataset[low:high+1] = ltemp

def merge_sort(dataset,low,high):
    if low < high:
        mid = (low+high) // 2
        merge_sort(dataset,low,mid)
        merge_sort(dataset,mid+1,high)
        merge_bisides(dataset,low,mid,high)
    return dataset

import random
lis = [i for i in range(100)]
random.shuffle(lis)
print(lis)

print(merge_sort(lis,0,len(lis)-1))

3. 插入排序

def insert_sort(dataset):
    length = list(dataset).__len__()
    for i in range(1,length): # i表示摸到的牌
        temp = dataset[i]
        j = i - 1
        while temp < dataset[j] and j >= 0:
            dataset[j+1] = dataset[j]
            j -= 1
        dataset[j+1] = temp
    return dataset

import random
if __name__ == '__main__':
    lis = [i for i in range(8)]
    random.shuffle(lis)
    print(lis)
    print(insert_sort(lis))

4. 冒泡排序

def bubble_sort(dataset,flag=True):
    for i in range(len(dataset)):
        for j in range(i,len(dataset)-1):
            temp = dataset[i]
            if flag:  # 升序
                if dataset[i] > dataset[j+1]:
                    dataset[i] = dataset[j+1]
                    dataset[j+1] = temp
            else:
                if dataset[i] < dataset[j+1]:
                    dataset[i] = dataset[j + 1]
                    dataset[j + 1] = temp
    return dataset
if __name__ == '__main__':
    dataset = [1,534,213,1543,123,5456,21]
    # bubble_sort(dataset)
    print(bubble_sort(dataset,False))

5. 选择排序

def opt_sort(dataset):
    dataset2 = []
    while len(dataset) > 0:
        m = min(dataset)
        dataset.remove(m)
        dataset2.append(m)
    return dataset2

if __name__ == '__main__':
    dataset = [1, 534, 213, 1543, 123, 5456, 21]
    print(opt_sort(dataset))

6. 堆排序

import random
def sift(dataset,low,high):     #调整为大根堆
    parent = low
    child = parent * 2 + 1
    temp = dataset[low]   #把堆顶存起来
    while child <= high:
        if child+1 <= high and dataset[child] < dataset[child+1]:
            child += 1
        if temp < dataset[child]:
            dataset[parent] = dataset[child]
            parent = child
            child = parent*2 + 1
        else:
            break
    dataset[parent] = temp

def create_heap(dataset):
    n = len(dataset)
    for parent in range((n-2)//2, -1, -1): # 从最后一个非叶子节点开始倒着走到整个堆的根节点，截止为0（即根节点）
        sift(dataset,parent,n-1)    #high固定为整个堆的最后一个元素的下标
    return dataset

def heap_sort(dataset):
    create_heap(dataset)
    n = len(dataset)
    for i in range(n-1,-1,-1):
        dataset[0], dataset[i] = dataset[i], dataset[0]
        sift(dataset,0,i-1) #i-1 是新的high
    return dataset

if __name__ == '__main__':
    dataset = [i for i in range(100)]
    random.shuffle(dataset)
    print(dataset)
    print(heap_sort(dataset))

7. 希尔排序

def insert_sort_gap(dataset,gap):
    for i in range(gap,len(dataset)):
        temp = dataset[i]
        j = i - gap
        while dataset[j] > temp and j >= 0:
            dataset[j+gap] = dataset[j]
            j -= gap
        dataset[j+gap] = temp

def shell_sort(dataset):
    d = len(dataset)
    gap = d // 2
    while gap >= 1:
        insert_sort_gap(dataset,gap)
        gap //= 2
import random
if __name__ == '__main__':
    lis = [i for i in range(9)]
    random.shuffle(lis)
    print(lis)
    shell_sort(lis)
    print(lis)

8. 计数排序

# 时间复杂度：O(n)

def count_sort(dataset,max_count = 100):
    count = [0 for _ in range(max_count)]
    for val in dataset:
        count[val] += 1
    dataset.clear()
    for num,fre in enumerate(count):
        for _ in range(fre):
            dataset.append(num)
    return dataset

if __name__ == '__main__':
    lis = [5,34,13,53,12,34,21,12,41,52,24,54,53,52,3,1,23,43]
    print(count_sort(lis))

9. 基数排序

# 多关键字排序

def radix_sort(dataset):
    n = max(dataset)
    it = 0  # 最大数的个数
    while 10 ** it <= n:
        buckets = [[] for _ in range(10)]
        for val in dataset:
            # 987 -> 987//1 = 987 -> 987%10 = 7
            #987 -> 987//10 = 98 -> 98%10 = 8
            digit = (val//10 ** it)%10
            buckets[digit].append(val)
        dataset.clear() #注意这里不能在重新新建空间，因为该排序的每一次循环都是基于上一次已经排好序的原buckets里
        for bucket in buckets:
            dataset.extend(bucket)
        it += 1
    return dataset
        
import random

if __name__ == '__main__':
    dataset = [random.randint(0,10000) for _ in range(99)]
    print(radix_sort(dataset))

10. 桶排序

# 时间复杂度取决于数据的分布

def bucket_sort(dataset,n = 100, max_count = 10000):
    buckets = [[] for _ in range(n)]
    for val in dataset:
        i = min(val//(max_count//n),n-1)
        buckets[i].append(val)
        for j in range(len(buckets[i])-2,-1,-1):    # 桶内排序
            if val < buckets[i][j]:
                buckets[i][j+1] = buckets[i][j]
            else:
                buckets[i][j+1] = val   # 注意这个语句不能写在for j的外面
    list_merge = []
    for bucket in buckets:
        list_merge.extend(bucket)
    return list_merge

import random
if __name__ == '__main__':
    lis = [random.randint(0,10000) for i in range(10)]
    print(bucket_sort(lis))