排序算法Python实现,快速排序算法python代码
1.排序是计算机语言需要实现的基本算法之一。有序的数据结构将大大提高效率。
以下是一些常见的排序算法：
气泡分选
冒泡排序的原理是遍历序列。如果在遍历过程中发现两个相邻的元素，并且左边的元素大于右边的元素，则交换它们。在一次遍历之后，将最大的元素移动到另一端，然后进行第二次遍历，直到队列有序。
# bubble sort def bubble _ sort(list):l=len(list)for I in range(l-1，0，-1):for j in range(I):if list[j]list[j 1]:list[j]，list [j 1]=list [j 1]，
排序的原理是先找到起始数组中最小的元素，交换到I=0；然后在剩下的元素中寻找最小的元素，交换到i=1的位置…直到找到第二大的元素，交换到n-2的位置。至此，整个数组的排序完成。
# select排序def select _ sort(list):length=len(list)for I in range(length):min=I for j in range(I，length):if list[j]list[min]:min=jlist [I]，list [min]=list [min]，list[I
设置任意一个基准元素，通常是第一个或最后一个，根据基准元素将序列分为较小的部分和较大的部分。此时，基准元素的位置就是排序完成后的准确位置，继续对左右序列进行同样的操作，直到整个序列都有序。
# quick sort def quick _ sort(list):if list==[]:return[]else:first=list[0]left=quick _ sort([l for l in list[1:]if l first])Right=quick _ sort([l for l in list[1:]if l first])return left[first]Rightinsert sort
把序列的第一个元素作为排序后的序列，然后从后面的第二个元素开始一个一个的插入，直到整个序列都是有序的。
# insert sort def insert _ sort(list):len=len(list)for I in range(1，length):for j in range(I):if list[j]list[j]:list[j]=list[j 1]，list [j] return list heap
这是一种选择性排序。您可以使用数组的特征来快速定位指定索引的元素。堆分为大根堆和小根堆，是一棵完整的二叉树。大根堆的要求是每个节点的值不大于其父节点的值，即A[PARENT[i]]=A[i]。在数组的非降序排序中，需要大根堆，因为根据大根堆的要求，最大值必须在堆的顶部。
# heap sort def heap _ sort(array):def heap _ adjust(parent):child=2 * parent 1 # left child while child len(heap):if child 1 len(heap):if heap[child]heap[parent]=heap[child]:break heap[parent]，heap[child]=\ heap[child]，heap[parent]，child=child，2 * child 1 heap，array=array.copy()，[] for i in range(len(heap) //2，-1，-1): heap_adjust(i)=0: heap [0]，heap [-1]=heap [-1]，heap [0] array.insert (0，heap.pop ()) heap _ adjust (0)返回数组合并排序
合并就是将数组拆分后再拆分，直到不能再拆分，然后将粒度最小的子数组合并，再将稍微大一点的数组合并，直到最后合成出最大的数组。它由两个功能完成，一个负责拆分，一个负责排序和合并。
#归并排序def merge _ sort(array):def merge _ arr(arr _ l，arr _ r):array=[]while len(arr _ l)and len(arr _ r):if arr _ l[0]=arr _ r[0]:array。append(arr _ l . pop(0))elif arr _ l[0]arr _ r[0]:数组。append(arr _ r . pop(0))if len(arr _ l)！=0: array=arr_l elif len(arr_r)！=0:数组=arr_r返回数组希尔排序
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至一时，整个文件恰被分成一组，算法便终止。
def shell _ sort(slist):gap=len(slist)while gap 1:gap=gap//2 for I in range(gap，len(slist)): for j in range(i % gap，I，gap):if slist[I]slist[j]:slist[I]，slist[j]=slist[j]，slist[I]返回列表2 .测试验证
从主导入*导入系统的导入时间。setrecursionlimit(100000000)def时间计数(func):def包装器(* arg，* * kwarg):start=time。clock()func(* arg，* * kwarg)end=time。clock()print( used:，end-start)返回包装类执行器(object):def _ _ init _ _(self，func，* * args，* * kwargs):self。func=func self。args=args self。kwargs=args * * self。kwargs)def _ _ del _ _(self):print(-end-)class test class(object):list=[]def testreadlist(self):for line in open( list。txt ):self。列表。追加(行。strip())打印(自。列表)#冒泡排序定义测试气泡(自身):执行器(bubble_sort，self.list) #快速排序def测试quick(self):Executor(quick _ sort，self.list) #选择排序定义测试选择(自身):执行器(select_sort，self.list) #插入排序def测试插入(self):执行程序(insert _ sort，self.list) #堆排序def testhead(self):Executor(heap _ sort，self.list) #归并排序定义测试合并(自身):执行器(merge_sort，self.list) #希尔排序def testshell(self):Executor(shell _ sort，self。list)def main(self):self。testreadlist()self。测试气泡()自身。快速()自我测试。测试选择()自身。测试插入()本身。测试头()自身。测试merge()自身。测试shell()if _ _ name _ _= _ _ main _ _ :测试类().主()
这里测试的200条数据和10000条数据进行的测试，但从计算速度上来看
1.归并排序效率最快
2.冒泡排序和希尔排序速度最慢
当然，对于上面提到的这些排序算法，并没有优劣之分，主要看关注点，也就是需求。综合去看待这些算法，我们可以通过以下几个方面（不完全)判断：时间复杂度，空间复杂度，待排序数组长度，待排序数组特点，程序编写复杂度，实际程序运行环境，实际程序可接受水平等等。各种需求和限制条件，程序快不快，占得空间，排序的数多不多，规律不规律，数据重合的多不多，运行机器配置，客户或者用户对运行时间的底线等等。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。