【Python】八大排序算法的比较
排序是数据处理比较核心的操作，八大排序算法分别是：直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、快速排序、归并排序、基数排序
以下是排序图解：
直接插入排序
思想
直接插入排序是一种最简单的插入排序。
插入排序：每一趟将一个待排序的记录，按照其关键字的大小插入到有序队列的合适位置里，知道全部插入完成。
在讲解直接插入排序之前，先让我们脑补一下我们打牌的过程。
先拿一张5在手里，
再摸到一张4，比5小，插到5前面，
摸到一张6，嗯，比5大，插到5后面，
摸到一张8，比6大，插到6后面，
。。。
最后一看，我靠，凑到全是同花顺，这下牛逼大了。
以上的过程，其实就是典型的直接插入排序，每次将一个新数据插入到有序队列中的合适位置里。
很简单吧，接下来，我们要将这个算法转化为编程语言。
假设有一组无序序列 R0, R1, ... , RN-1。
(1) 我们先将这个序列中下标为 0 的元素视为元素个数为 1 的有序序列。
(2) 然后，我们要依次把 R1, R2, ... , RN-1 插入到这个有序序列中。所以，我们需要一个外部循环，从下标 1 扫描到 N-1 。
(3) 接下来描述插入过程。假设这是要将 Ri 插入到前面有序的序列中。由前面所述，我们可知，插入Ri时，前 i-1 个数肯定已经是有序了。
所以我们需要将Ri 和R0 ~ Ri-1 进行比较，确定要插入的合适位置。这就需要一个内部循环，我们一般是从后往前比较，即从下标 i-1 开始向 0 进行扫描。
实现
L = [3,2,1,9,6] #定义一组数据 def insert_sort(lists): for j in range(1, len(lists)): # 假设第一个数是排序好的 key = lists[j] # 取出当前未排序的数 i = j-1 # 从后往前，先取未排序数的前一个数（已经排序好的数） while i >= 0 and lists[i] > key: # 若当前未排序的数比排序好的数还小 并且没有到数组的开头 lists[i+1] = lists[i] # 排序好的数往后挪一个位置 i = i-1 # 取排序好的数的前一个数进行比较 lists[i+1] = key # 插入当前要排序的数 return lists L1 = insert_sort(L) print(L1)
运行结果：
[1, 2, 3, 6, 9]
效率
时间复杂度：O（n^2）
希尔排序
思想
先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率比直接插入排序有较大提高。
首先要明确一下增量的取法： 第一次增量的取法为： d=count/2;
第二次增量的取法为: d=(count/2)/2;
最后一直到: d=1; 看上图观测的现象为： d=3时：将9跟8比，因9大，交换。
将6跟1比，因6大，交换。
将7跟2比，因7小，交换。
d=2时
第一次比较 ：8跟2比较，8大，与2互换位置【 2，6，8，9，1，7】
第二次比较：8跟1比较，8大，与1互换位置【 2，6，1，9，8，7】
此时我们发现2跟1的位置，2大，那么交换位置【 1，6，2，9，8，7】
第三次比较：6跟9比较，不换位置 【 1，6，2，9，8，7】
第四次比较：9跟7比较，9大 互换位置【 1，6，2，7，8，9】
d=1时：这时就是前面讲的插入排序了，不过此时的序列已经差不多有序了，所以给插入排序带来了很大的性能提高
实现
def shell_sort(lists): count = len(lists) step = 2 group = int(count/step) while group>0: for i in range(group): j = i + group while j<count: key = lists[j] k = j-group while k>=0: if lists[k]>key: lists[k+group]=lists[k] lists[k]=key k=k-group j=j+group group=int(group/step) return lists lists = [9,6,7,8,1,2] M = shell_sort(lists) print(M)
效率
时间复杂度：O(n)
空间复杂度：O(n√n)
稳定性：不稳定
简单选择排序
思想
在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。
第一次：从n 个记录中找出关键码最小的记录与第一个记录交换；
第二次：从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；
以此类推.....
第n-1次：则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，
实现
def select_sort(alist): for i in range(len(alist)-1,0,-1): maxone = 0 for j in range(1,i+1): if alist[j]>alist[maxone]: maxone = j temp = alist[i] alist[i] = alist[maxone] alist[maxone] = temp return alist list = [9,6,7,8,1,2] m = select_sort(list) print(m)
效率
简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元素，则比较次数总是N (N - 1) / 2。
而移动次数与序列的初始排序有关。当序列正序时，移动次数最少，为 0.
当序列反序时，移动次数最多，为3N (N - 1) / 2。
所以，综合以上，简单排序的时间复杂度为 O(N2)。
堆排序
思想
堆是一棵顺序存储的完全二叉树。
其中每个结点的关键字都不大于其孩子结点的关键字，这样的堆称为小根堆。
其中每个结点的关键字都不小于其孩子结点的关键字，这样的堆称为大根堆。
举例来说，对于n个元素的序列{R0, R1, ... , Rn}当且仅当满足下列关系之一时，称之为堆：
(1) Ri <= R2i+1 且 Ri <= R2i+2 (小根堆)
(2) Ri >= R2i+1 且 Ri >= R2i+2 (大根堆)
其中i=1,2,…,n/2向下取整;
如上图所示，序列R{3, 8, 15, 31, 25}是一个典型的小根堆。
堆中有两个父结点，元素3和元素8。
元素3在数组中以R[0]表示，它的左孩子结点是R[1]，右孩子结点是R[2]。
元素8在数组中以R[1]表示，它的左孩子结点是R[3]，右孩子结点是R[4]，它的父结点是R[0]。可以看出，它们满足以下规律：
设当前元素在数组中以R[i]表示，那么，
(1) 它的左孩子结点是：R[2*i+1];
(2) 它的右孩子结点是：R[2*i+2];
(3) 它的父结点是：R[(i-1)/2];
(4) R[i] <= R[2*i+1] 且 R[i] <= R[2i+2]。
首先，按堆的定义将数组R[0..n]调整为堆（这个过程称为创建初始堆），交换R[0]和R[n]；
然后，将R[0..n-1]调整为堆，交换R[0]和R[n-1]；
如此反复，直到交换了R[0]和R[1]为止。
以上思想可归纳为两个操作：
（1）根据初始数组去构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大）。
（2）每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。
当输出完最后一个元素后，这个数组已经是按照从小到大的顺序排列了。
先通过详细的实例图来看一下，如何构建初始堆。
设有一个无序序列 { 1, 3, 4, 5, 2, 6, 9, 7, 8, 0 }。
构造了初始堆后，我们来看一下完整的堆排序处理：
还是针对前面提到的无序序列 { 1, 3, 4, 5, 2, 6, 9, 7, 8, 0 } 来加以说明。
实现
def swap(a, b): # 将a,b交换 temp = a a = b b = temp return a,b def sift_down(array, start, end): """ 调整成大顶堆，初始堆时，从下往上；交换堆顶与堆尾后，从上往下调整 :param array: 列表的引用 :param start: 父结点 :param end: 结束的下标 :return: 无 """ while True: # 当列表第一个是以下标0开始，结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2; # 若下标以1开始，左孩子则为2*i,右孩子则为2*i+１ left_child = 2*start + 1 # 左孩子的结点下标 # 当结点的右孩子存在，且大于结点的左孩子时 if left_child > end: break if left_child+1 <= end and array[left_child+1] > array[left_child]: left_child += 1 if array[left_child] > array[start]: # 当左右孩子的最大值大于父结点时，则交换 array[left_child], array[start] = swap(array[left_child], array[start]) start = left_child # 交换之后以交换子结点为根的堆可能不是大顶堆，需重新调整 else: # 若父结点大于左右孩子，则退出循环 break print(">>", array) def heap_sort(array): # 堆排序 # 先初始化大顶堆 first = len(array)//2 -1 # 最后一个有孩子的节点(//表示取整的意思) # 第一个结点的下标为０ for i in range(first, -1, -1): # 从最后一个有孩子的节点开始往上调整 print(array[i]) sift_down(array, i, len(array)-1) # 初始化大顶堆 print("初始化大顶堆结果:", array) # 交换堆顶与堆尾 for head_end in range(len(array)-1, 0, -1): # start stop step array[head_end], array[0] = swap(array[head_end], array[0]) # 交换堆顶与堆尾 sift_down(array, 0, head_end-1) # 堆长度减一(head_end-1)，再从上往下调整成大顶堆 if __name__ == "__main__": array = [16, 7, 3, 20, 17, 8] print(array) heap_sort(array) print("堆排序最终结果:", array)
效率
堆的存储表示是顺序的。因为堆所对应的二叉树为完全二叉树，而完全二叉树通常采用顺序存储方式。
当想得到一个序列中第k个最小的元素之前的部分排序序列，最好采用堆排序。
因为堆排序的时间复杂度是O(n+klog2n)，若k≤n/log2n，则可得到的时间复杂度为O(n)。
冒泡排序
思想
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
说明：图中标记的绿色为每一轮排序后确定的元素
实现
#创建排序算法 def buddle_sort(data): for i in range(0,len(data)): for j in range(i,len(data)): if(data[i] > data[j]): data[i],data[j] = data[j],data[i] return data #编写实例验证 lis = [2,4,1,5,3] act_lis = buddle_sort(lis) print(act_lis)
运行结果：
[1, 2, 3, 4,5]
效率
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：Cmin = N - 1, Mmin = 0。所以，冒泡排序最好时间复杂度为O(N)。
若初始文件是反序的，需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)。
因此，冒泡排序的平均时间复杂度为O(N2)。
总结起来，其实就是一句话：当数据越接近正序时，冒泡排序性能越好。
快速排序
思想
快速排序是一种交换排序。
快速排序由C. A. R. Hoare在1962年提出。
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。
然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
详细的图解往往比大堆的文字更有说明力，所以直接上图：
上图中，演示了快速排序的处理过程：
初始状态为一组无序的数组：2、4、5、1、3。
经过以上操作步骤后，完成了第一次的排序，得到新的数组：1、2、5、4、3。
新的数组中，以2为分割点，左边都是比2小的数，右边都是比2大的数。
因为2已经在数组中找到了合适的位置，所以不用再动。
2左边的数组只有一个元素1，所以显然不用再排序，位置也被确定。（注：这种情况时，left指针和right指针显然是重合的。因此在代码中，我们可以通过设置判定条件left必须小于right，如果不满足，则不用排序了）。
而对于2右边的数组5、4、3，设置left指向5，right指向3，开始继续重复图中的一、二、三、四步骤，对新的数组进行排序。
实现
#coding:utf-8 def qsort(L): if len(L) <= 1: return L return qsort([lt for lt in L[1:] if lt < L[0]]) + L[0:1]+ \ qsort([ge for ge in L[1:] if ge >= L[0]]) iList = [3,14,2,12,9,33,99,35] print(qsort(iList))
效率
当数据有序时，以第一个关键字为基准分为两个子序列，前一个子序列为空，此时执行效率最差。
而当数据随机分布时，以第一个关键字为基准分为两个子序列，两个子序列的元素个数接近相等，此时执行效率最好。
所以，数据越随机分布时，快速排序性能越好；数据越接近有序，快速排序性能越差。
归并排序
思想
将待排序序列R[0...n-1]看成是n个长度为1的有序序列，将相邻的有序表成对归并，得到n/2个长度为2的有序表；将这些有序序列再次归并，得到n/4个长度为4的有序序列；如此反复进行下去，最后得到一个长度为n的有序序列。
综上可知：
归并排序其实要做两件事：
（1）“分解”——将序列每次折半划分。
（2）“合并”——将划分后的序列段两两合并后排序。
我们先来考虑第二步，如何合并？
在每次合并过程中，都是对两个有序的序列段进行合并，然后排序。
这两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]。
先将他们合并到一个局部的暂存数组R2中，带合并完成后再将R2复制回R中。
为了方便描述，我们称 R[low, mid] 第一段，R[mid+1, high] 为第二段。
每次从两个段中取出一个记录进行关键字的比较，将较小者放入R2中。最后将各段中余下的部分直接复制到R2中。
经过这样的过程，R2已经是一个有序的序列，再将其复制回R中，一次合并排序就完成了。
图解：
在某趟归并中，设各子表的长度为gap，则归并前R[0...n-1]中共有n/gap个有序的子表：R[0...gap-1], R[gap...2*gap-1], ... , R[(n/gap)*gap ... n-1]。
调用Merge将相邻的子表归并时，必须对表的特殊情况进行特殊处理。
若子表个数为奇数，则最后一个子表无须和其他子表归并（即本趟处理轮空）：若子表个数为偶数，则要注意到最后一对子表中后一个子表区间的上限为n-1。
实现
def merge_sort( li ): #不断递归调用自己一直到拆分成成单个元素的时候就返回这个元素，不再拆分了 if len(li) == 1: return li #取拆分的中间位置 mid = len(li) // 2 #拆分过后左右两侧子串 left = li[:mid] right = li[mid:] #对拆分过后的左右再拆分 一直到只有一个元素为止 #最后一次递归时候ll和lr都会接到一个元素的列表 # 最后一次递归之前的ll和rl会接收到排好序的子序列 ll = merge_sort( left ) rl =merge_sort( right ) # 我们对返回的两个拆分结果进行排序后合并再返回正确顺序的子列表 # 这里我们调用拎一个函数帮助我们按顺序合并ll和lr return merge(ll , rl) #这里接收两个列表 def merge( left , right ): # 从两个有顺序的列表里边依次取数据比较后放入result # 每次我们分别拿出两个列表中最小的数比较，把较小的放入result result = [] while len(left)>0 and len(right)>0 : #为了保持稳定性，当遇到相等的时候优先把左侧的数放进结果列表，因为left本来也是大数列中比较靠左的 if left[0] <= right[0]: result.append( left.pop(0) ) else: result.append( right.pop(0) ) #while循环出来之后 说明其中一个数组没有数据了，我们把另一个数组添加到结果数组后面 result += left result += right return result if __name__ == '__main__': li = [5,4 ,3 ,2 ,1] li2 = merge_sort(li) print(li2)
效率
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(n*log2n)。
基数排序
思想
基数排序与本系列前面讲解的七种排序方法都不同，它不需要比较关键字的大小。
它是根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。
不妨通过一个具体的实例来展示一下，基数排序是如何进行的。
设有一个初始序列为: R {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}。
我们知道，任何一个阿拉伯数，它的各个位数上的基数都是以0~9来表示的。
所以我们不妨把0~9视为10个桶。
我们先根据序列的个位数的数字来进行分类，将其分到指定的桶中。例如：R[0] = 50，个位数上是0，将这个数存入编号为0的桶中。
分类后，我们在从各个桶中，将这些数按照从编号0到编号9的顺序依次将所有数取出来。
这时，得到的序列就是个位数上呈递增趋势的序列。
按照个位数排序： {50, 30, 0, 100, 11, 2, 123, 543, 187, 49}。
接下来，可以对十位数、百位数也按照这种方法进行排序，最后就能得到排序完成的序列。
实现
def radix_sort(array): bucket, digit = [[]], 0 while len(bucket[0]) != len(array): bucket = [[], [], [], [], [], [], [], [], [], []] for i in range(len(array)): num = (array[i] // 10 ** digit) % 10 bucket[num].append(array[i]) array.clear() for i in range(len(bucket)): array += bucket[i] digit += 1 return array li = [50, 30, 0, 100, 11, 2, 123, 543, 187, 49] li2 = radix_sort(li) print(li2)
效率
假设在基数排序中，r为基数，d为位数。则基数排序的时间复杂度为O(d(n+r))。
我们可以看出，基数排序的效率和初始序列是否有序没有关联。
参考地址：http://www.cnblogs.com/jingmoxukong/category/528514.html
声明：书写博客不易，转载请注明出处，请支持原创，侵权将追究法律责任
个性签名：人的一切的痛苦，本质上都是对自己无能的愤怒
如果觉得这篇文章对你有小小的帮助的话，记得在右下角点个“推荐”哦，博主在此感谢！
