n

希尔排序

插入排序的一种变形
def insert_sort_gap(li,gap):
    for i in range(gap,len(li)):
        tmp = li[i]
        j = i-gap
        while j>=0 and li[j]>tmp:
            li[j+gap] =li[j]
            j-=gap
        li[j+gap]=tmp
def shell_sort(li):
    d=len(li)//2
    while d>=1:
        insert_sort_gap(li,d)
        d//=2
li = list(range(100000))
shell_sort(li1)
print(li)
# 速度比堆排还慢
# 时间复杂度于gap有关        

 

计数排序

# 数一数每一种值的个数
# 时间复杂度O(N)    有限制
def count_sort(li,max_count=100):
    count = [0 for i in range(max_count+1)]
    for val in li:
        count[val] +=1
    li.clear()
    for ind,val in enumerate(count):
        for i in range(val):
            li.append(ind)
import random
li = [random.randint(0,100) for i in range(1000)]
print(li)
count_sort(li)
print(li)

 

桶排序

# 表现取决于数据的分布。也就是需要对不同数据排序时采取不同的分桶策略
# 平均情况时间复杂度：O(N+K)
# 最坏情况时间复杂度：O(n*n*k)
# 空间复杂度O(nk)
# 对计数排序做了一些修改

def bucket_sort(li,n=100,max_num=10000):
    buckets = [[] for i in range(n)]    # 创建桶
    for var in li:
        i = min(var // (max_num//n), n-1)    # i 表示var放到几号桶里
        buckets[i].append(var) # 把var加到通里边
        # 保持桶内的顺序
        for j in range(len(buckets[i][j-1])-1,0,-1):
            if buckets[i][j] < buckets[i][j-1]:
                buckets[i][j],buckets[i][j-1] = buckets[i][j-1],buckets[i][j]
            else:
                break
    sorted_li = []
    for buc in buckets:
        sorted_li.extend(buc)
    return sorted_li
li = [random.randint(0,10000) for i in range(10000)]
li = bucket_sort(li)
print(li)

 

基数排序

# 时间复杂度O(kn)
# 空间复杂度O(k+n)
# k表示数字位数
def radix_sort(li):
    max_num = max(li)
    it =0
    while 10**it <= max_num:
        buckets = [[] for i in range(10)]
        for var in li:
            digit = (var // 10**it)%10
            buckets[digit].append(var)
        li.clear()
        for buc in buckets:
            li.extend(buc)
        it+=1
import random
li =list(range(10000))
random.shuffle(li)
radix_sort(li)
print(li)