数据结构与算法五（希尔排序、计数排序、桶排序、基数排序）

（1）希尔排序
希尔排序（Shell Sort）是一种分组插入排序算法

• 首先取一个整数d1=n/2,将元素分为d1个组，每组相邻量元素之间距离为d1，在各组内进行直接插入排序。
• 取第二个整数d2=d1/2，重复上述分组排序过程，直到di=1，即所有元素在同一组内进行直接插入排序。
• 希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序。
  希尔排序的代码实现

def insert_sort_gap(li,gap):
    for i in range(gap,len(li)):#i表示摸到的牌的下标
        tmp=li[i]
        j=i-gap#j指的是手里的牌的下标
        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(1000))
import random
random.shuffle(li)
shell_sort(li)
print(li)

希尔排序的时间复杂度讨论比较复杂，并且和选取的gap序列有关。
（2）计数排序
对列表进行排序，已知列表中的数范围都在0到100之间。设计时间复杂度为O(n)的算法
计数排序的代码实现

def count_sort(li,max_count=100):
    count=[0 for _ 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 _ in range(1000)]
print(li)
count_sort(li)
print(li)            

（3）桶排序
桶排序（Bucket Sort）:首先将元素分在不同的桶中，再对每个桶中的元素排序

桶排序的代码实现

def bucket_sort(li,n=100,max_num=10000):#n指桶的个数，max_num表示最大的数
    buckets=[[] for _ in range(n)]#创建一各二维列表,一个桶放max_num//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])-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

import random
li=[random.randint(0,10000) for i in range(10000)]
li=bucket_sort(li)
print(li)

桶排序的表现取决于数据的分布。也就是需要对不同数据排序时采取不同的分桶策略。
平均情况时间复杂度：O(n+k)（n为列表的长度，m为桶的个数，k=logm*logn）
最坏情况时间复杂度：O(n²k)
空间复杂度：O(nk)
（4）基数排序
多关键字排序：现在有一个员工表，要求按照薪资排序，薪资相同的员工按照年龄排序。（更快的实现：先按照年龄进行排序，再按照薪资进行稳定的排序）
基数排序代码实现

def radix_sort(li):
    max_num=max(li)#最大值
    it=0
    while 10**it<=max_num:
        buckets=[[] for _ in range(10)]
        for var in li:
            #987 it=1 987//10->98 98%10->8;it=2 987//100->9 9%10->9
            digit=(var//10**it)%10
            buckets[digit].append(var)
            #分桶完成
        li.clear()
        for buc in buckets:
            li.extend(buc)#把数重新写回li
        it+=1
 
import random
li=list(range(1000))
random.shuffle(li)
radix_sort(li)
print(li)

基数排序的时间复杂度：O(kn) k表示最大的位数
基数排序的空间复杂度：O(k+n)