算法——其他排序算法

一、希尔排序（Shell Sort）

　　希尔排序(Shell Sort)是一种分组插入排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n²）的第一批算法之一。

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、希尔排序代码实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

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、测试希尔排序性能 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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(n²)类的算法（插入排序）更好，但这样仍然有减少平均时间和最差时间的余地。

　　

　　更多不同gap情况时间复杂度：https://en.wikipedia.org/wiki/Shellsort#Gap_sequences

二、计数排序 

　　对列表进行排序，已知列表中的数范围都在0到100之间。设计时间复杂度为O(n)的算法。

　　统计每个数字出现了几次。

1、计数排序代码实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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函数性能对比

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

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、桶排序初步代码实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

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(n²k)，最坏情况下比O(n²)还要高。

　　空间复杂度：O(nk)，占用了一个桶的空间，占用了O(nk)。

四、基数排序（radix sort）

　　基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序。

1、多关键字排序

　　假如现在有一个员工表，要求按照薪资排序，薪资相同的员工按照年龄排序。

　　先按照年龄进行排序，再按照薪资进行稳定的排序。

　　对32,13,94,52,17,54,93排序，是否可以看作多关键字排序？可以，十位看作是第一关键字，个位看作是第二关键字。

2、图解多关键字排序

　　先按照个位分桶：

　　

　　接下来依次输出每个桶的数据：

　　

　　这样就实现了按个位数进行排序，满足了个位数小的一定在前面

　　接下来要按照十位数来分桶：

　　

　　再次依次输出每个桶的数据：

　　

3、基数排序代码实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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)

 分拆函数的写法：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

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 = log₁₀n，而快速排序是O(nlog₂n)。由此可见基数排序比快排要快。但是当数字范围越来越大，k越来越大时，效率会慢于快排。

　　空间复杂度：O(k+n)，基数排序空间上会消耗一个桶，空间消耗也是比较大的。因此最常用的还是快速排序和python自带的排序