算法——其他排序算法
一、希尔排序（Shell Sort）
希尔排序(Shell Sort)是一种分组插入排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。
1、算法思路
首先取一个整数d1=n/2，将元素分为d1个组，每组相邻量元素之间距离为d1，在各组内进行直接插入排序；
取第二个整数d2=d1/2，重复上述分组排序过程，直到di=1，即所有元素在同一组
希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序。
2、算法思路图解
例如有一个列表有九个元素如下所示：
（1）第一趟排序
取d1=9/2得到d1=4，将整个列表分为4组，每组相邻元素间距离为4：
将各个组内进行插入排序：
排序完成后，将这些元素返回列表：
（2）第二趟排序
取d2=d1/2，得到d2=2，将整个列表分为2组，每组相邻元素间距为2：
再在各个组内进行插入排序：
排序完成后，再将这些元素返回列表：
（3）最后一趟排序
此时d3=d2/2，得到d3=1，此时直接进行插入排序：
如此整个排序过程就完成了。希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序。
3、希尔排序代码实现
def insert_sort_gap(li, gap):
"""
希尔排序的分组进行插入排序
:param li:列表
:param gap:分组的d，将插入排序所有的1改为gap
:return:
"""
for i in range(gap, len(li)): # i表示摸到牌的下标
tmp = li[i] # 摸到的牌
j = i - gap # j指得是手里牌的下标(比摸到的牌小gap)
while li[j] > tmp and j >= 0: # 循环条件
li[j + gap] = li[j] # 如果手里的牌大于摸到的牌，将摸到的牌换为之前手里的牌
j -= gap # 手里的牌移动到摸到牌的位置
li[j + gap] = tmp # 将摸到的牌插入有序区
# print(li) # 打印每一趟排序过程
def shell_sort(li):
"""希尔排序"""
d = len(li) // 2 # 取到第一次循环的d值
while d >= 1: # 每次循环d/2，知道d=1的时候结束循环
insert_sort_gap(li, d)
d //= 2 # d整除2并赋值给d
li = list(range(100))
import random
random.shuffle(li)
shell_sort(li)
print(li)
在希尔排序的理解时，我们倾向于对于每一个分组，逐组进行处理，但在代码实现中，我们可以不用这么按部就班地处理完一组再调转回来处理下一组（这样还得加个for循环去处理分组）比如[5,7,4,6,3,1,2,9,8] ，首次增量设gap=length/2=4,则为4组[5,3,8] [7,1] [4,2] [6,9]，实现时不用循环按组处理，我们可以从第gap个元素开始，逐个跨组处理。
4、测试希尔排序性能
from cal_time import *
import copy, random
def insert_sort_gap(li, gap):...
@cal_time
def shell_sort(li):
"""希尔排序"""
d = len(li) // 2 # 取到第一次循环的d值
while d >= 1: # 每次循环d/2，知道d=1的时候结束循环
insert_sort_gap(li, d)
d //= 2 # d整除2并赋值给d
from insert_sort import insert_sort
from heap_sort import *
li = list(range(10000))
random.shuffle(li)
li1 = copy.deepcopy(li)
li2 = copy.deepcopy(li)
li3 = copy.deepcopy(li)
shell_sort(li1)
insert_sort(li2)
"""
shell_sort running time: 0.05884504318237305 secs.
insert_sort running time: 4.995609283447266 secs.
"""
shell_sort(li1)
heap_sort(li3)
"""
shell_sort running time: 0.05833792686462402 secs.
heap_sort running time: 0.04569196701049805 secs.
"""
由此可见希尔排序的运行效率要远远大于插入排序，与堆排序（牛逼三人组中最慢）相比略慢一点。
5、希尔排序的时间复杂度
希尔排序的时间复杂度比较复杂，且与选择的gap(步长)序列有关。
只要最终步长为1任何步长序列都可以工作。算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为普通插入排序，这就保证了数据一定会被排序。
Donald Shell最初建议步长选择为n/2并且对步长取半直到步长达到1。虽然这样取可以比O(n2)类的算法（插入排序）更好，但这样仍然有减少平均时间和最差时间的余地。
更多不同gap情况时间复杂度：https://en.wikipedia.org/wiki/Shellsort#Gap_sequences
二、计数排序
对列表进行排序，已知列表中的数范围都在0到100之间。设计时间复杂度为O(n)的算法。
统计每个数字出现了几次。
1、计数排序代码实现
def count_sort(li, max_count=100):
"""
计数排序
:param li:
:param max_count:
:return:
"""
count = [0 for _ in range(max_count+1)] # 生成一个值全为0长度为100+1的列表
for val in li: # 遍历li列表的值
count[val] += 1 # 值对应count列表下标，遍历到便执行加1
# 这样设计也限制了不能用大于100的数字进行排序，因为超出了index下标的范围
li.clear() # 列表清空
for ind, val in enumerate(count): # 下标、值
for i in range(val): # 遍历值（对应下标的统计次数）
li.append(ind) # 将下标值添加到li列表中（统计了几次就添加几次）
import random
li = [random.randint(0, 100) for _ in range(10)]
print(li)
count_sort(li)
print(li)
count[val] += 1是代码的精髓，不仅统计了对应值的出现次数，完成了排序，还限制了不能用大于下标范围的数字进行排序，如果超出下标返回，会提示报错。
2、计数排序和系统内置sort函数性能对比
from cal_time import *
@cal_time
def count_sort(li, max_count=100):
"""
计数排序
:param li:
:param max_count:
:return:
"""
count = [0 for _ in range(max_count+1)] # 生成一个值全为0长度为100+1的列表
for val in li: # 遍历li列表的值
count[val] += 1 # 值对应count列表下标，遍历到便执行加1
li.clear() # 列表清空
for ind, val in enumerate(count): # 下标、值
for i in range(val): # 遍历值（对应下标的统计次数）
li.append(ind) # 将下标值添加到li列表中（统计了几次就添加几次）
@cal_time
def sys_sort(li):
li.sort()
import random,copy
li = [random.randint(0, 100) for _ in range(100000)]
li1 = copy.deepcopy(li)
li2 = copy.deepcopy(li)
count_sort(li1)
sys_sort(li2)
"""
count_sort running time: 0.0277559757232666 secs.
sys_sort running time: 0.02849888801574707 secs.
"""
系统排序是用c语言写的，因此运行效率很高，在这里可以看到计数排序效率比系统排序还要高。
3、计数排序时间复杂度
对列表进行排序，已知列表中的数范围都在0到100之间。设计时间复杂度为O(n)的算法。0-100需要消耗一个长度是100的列。如果是一亿就要开一亿长的列。
常用于年龄等排序。此时不再往里面append值，而是append对象。
三、桶排序（Bucket Sort）
在计数排序中，如果遇到元素值的范围比较大（比如在1到1亿之间），是不适用的，改造算法就有桶排序。
桶排序：首先将元素分在不同的桶中，再对每个桶中的元素排序。
1、桶排序初步代码实现
def bucket_sort(li, n=100, max_num=10000):
"""
桶排序
:param li:
:param n: 桶的个数
:param max_num: 数字最大值
:return:
"""
buckets = [[] for _ in range(n)] # 创建桶：列表生成式生成二维列表，[[], [],...,[]]
for var in li: # 遍历列表所有数放在合适的桶里
# i = var // (max_num // n) # i表示var放到几号桶里86//(10000//100)=0,所以放在0号桶，但是处理不了10000
i = min(var // (max_num // n), n-1) # 为了解决10000这个数，将原i值和n-1=99作比较取小
buckets[i].append(var) # 将var放入对应的桶内
# 保持桶内的顺序(插入排序)
for j in range(len(buckets[i])-1, 0, -1): # 在列表[4,7,2,5]从后往前倒着取值
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: # buc是每一个桶
sorted_li.extend(buc)
return sorted_li
import random
li = [random.randint(0,10000) for i in range(100000)]
print(li)
li = bucket_sort(li)
print(li)
2、桶排序的性能
桶排序的表现取决于数据的分布，也就是需要对不同的数据排序时采取不同的分桶策略。
n是列表的长度，k是桶的个数。
平均情况事件复杂度：O(n+k)，类似于线性的复杂度。
最坏情况时间复杂度：O(n2k)，最坏情况下比O(n2)还要高。
空间复杂度：O(nk)，占用了一个桶的空间，占用了O(nk)。
四、基数排序（radix sort）
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序。
1、多关键字排序
假如现在有一个员工表，要求按照薪资排序，薪资相同的员工按照年龄排序。
先按照年龄进行排序，再按照薪资进行稳定的排序。
对32,13,94,52,17,54,93排序，是否可以看作多关键字排序？可以，十位看作是第一关键字，个位看作是第二关键字。
2、图解多关键字排序
先按照个位分桶：
接下来依次输出每个桶的数据：
这样就实现了按个位数进行排序，满足了个位数小的一定在前面
接下来要按照十位数来分桶：
再次依次输出每个桶的数据：
3、基数排序代码实现
def radix_sort(li):
"""基数排序,装桶输出不做排序"""
max_num = max(li) # 最大值99->2, 888->3, 10000->5
it = 0
while 10 ** it <= max_num: # 如果10的it次方小于等于max_num，即满足循环条件
buckets = [[] for _ in range(10)] # 生成10个桶
for var in li:
"""
取数字个位数的值：987%10 取余
取数字十位数的值：(987//10)%10 取整再取余
取数字百位数的值：(987//100)%10 对100取整再取余
"""
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)
分拆函数的写法：
def list_to_buckets(li, base, iteration):
"""
列表到桶
:param li:
:param base: 分的桶的个数
:param iteration: 装桶是第几次迭代
:return:
"""
buckets = [[] for _ in range(base)]
for number in li:
digit = (number // (base ** iteration)) % base
buckets[digit].append(number)
return buckets
def buckets_to_list(buckets):
return [x for bucket in buckets for x in bucket]
# li = []
# for bucket in buckets:
# for num in bucket:
# li.append(num)
def radix_sort(li, base=10):
maxval = max(li)
it = 0
while base ** it <= maxval:
li = buckets_to_list(list_to_buckets(li, base, it))
it += 1
return li
import random
li = [random.randint(0,100) for _ in range(10)]
random.shuffle(li)
s = radix_sort(li)
print(s) # [3, 10, 22, 27, 38, 43, 45, 54, 59, 72]
4、基数排序的特性和效率
时间复杂度：O(kn)，这里的k = log10n，而快速排序是O(nlog2n)。由此可见基数排序比快排要快。但是当数字范围越来越大，k越来越大时，效率会慢于快排。
空间复杂度：O(k+n)，基数排序空间上会消耗一个桶，空间消耗也是比较大的。因此最常用的还是快速排序和python自带的排序
