Python排序函数,Python中排序函数

　　排序是一种常用的算法。其实实现的方式有很多种，比如冒泡排序、选择排序、归并排序、希尔排序、快速排序等等。今天，本文将介绍使用python语言实现这些排序算法。

　　冒泡排序冒泡排序是最常见的排序算法，也是大学里遇到的第一种排序算法。它的实现思路是：比较两个相邻的元素，然后把较大的元素放在后面(正向排序)。一轮比较下来，最大的元素放在最后一个位置。因为这就像一条鱼在水中吐的泡泡在上升过程中不断变大，所以命名为泡泡排序。在这个排序算法中，要遍历n-1轮，每轮都要比较数组中的元素，所以时间复杂度为

　　氧气.具体代码如下：

　　def bubble _ sort(a list):length=len(a list)for I in range(length-1):# I表示对range (length-i-1)中J进行了多少轮比较：# j表示每轮比较的元素的范围，因为每个比较轮中一个元素的位置都会被排序，#在下一个比较轮中会少比较一个元素，所以I if a list [j]a list[J]:a list[J]，a list[J]=a list[J 1]，a list[J]

　　在比较的过程中，相同的元素不会交换，所以冒泡排序是一种稳定的排序算法。

　　选择排序的思路是：第一轮，所有元素与第一个元素进行比较。如果比第一个元素大，就和第一个元素交换。经过这一轮比较，找到最小的元素；在第二轮中，将所有元素与第二个元素进行比较，以找到第二个位置的元素，依此类推。

　　每次遍历安排一个元素，每次比较所有元素，时间复杂度为O(n2)。因为相同的元素位置在交换过程中可能会发生变化，所以选择排序是不稳定的。具体实现代码如下：

　　selection _ sort(a list):length=len(a list)for I in range(length-1，0，-1):for j in range(I):if a list[j]a list[I]:a list[j]，a list [I]=a list [I]，a list

　　插入的工作原理是构造一个有序序列，在已排序的序列中从后向前扫描未排序的数据，找到对应的位置并插入。在插入的实现中，从后向前扫描的过程中，需要将排序后的元素一步一步地反复向后移动，为最新的元素提供插入空间。如图所示：

　　插入的时间复杂度为O(n2)。

　　的具体实现代码如下：

　　Def _ sort (a list):对于range中的I(1，len (a list)): #从第二个元素开始，一次取出一个元素，插入前面的序列使其有序对于range中的j(I，0，-1):if a list[j]a list[j-1]:a list[j]，

　　Quicksort(英文：quick sort)又称分区交换排序(partition-exchange sort)，通过一次排序将待排序的数据分成两个独立的部分，其中一部分的所有数据小于另一部分的所有数据，然后按照这种方法对这两部分数据进行快速排序。整个排序过程可以递归进行，使整个数据成为有序序列。

　　这些步骤是：

　　从序列中挑选出一个元素，称为“pivot”，通常是第一个元素。对数列重新排序，所有小于参考值的元素放在参考值的前面，所有大于参考值的元素放在参考值的后面(相同的数字可以在两边)。在这个分区结束后，基准位于系列的中间。这称为分区操作。递归排序小于参考值的元素子系列和大于参考值的元素子系列。在递归的最底层，序列的大小是零或一，也就是一直排序下去。虽然它一直在递归，但这个算法总会结束，因为在每次迭代中，它至少会将一个元素放到它的最后一个位置。

　　def quick_sort(alist，start，End):if Start=End:return low=Start high=End mid=a list[low]while low high:while low high and mid a list[high]:#从右开始。如果元素小于基准，则将此元素放在左侧high-=1 list[low]=list[high]while low high and mid list[low]:#从左侧开始查找。如果元素大于基准，将元素放在右边low=1 alist[high]=alist[low] #要循环出，Low==high，将基准元素放在这个位置。list[low]=mid #递归调用，重新排列左右序列quick _ sort(list，START，LOW-1)quick _ sort(list，LOW1，END)

　　因为每次序列被分成两部分，如果n次切割元素后序列长度为m，那么2n=m，切割的时间复杂度为log(n)，每次切割都会比较所有元素，需要n次，所以总的时间复杂度为O(nlog(n))。在比较的过程中，元素的位置可能会移动，所以快速排序是不稳定排序。

　　希尔排序(Shell排序)是一种插入排序。也称为减少增量排序，它是直接插入排序算法的一个更有效和改进的版本。希尔排序是一种不稳定的排序算法。这种方法以DL命名。壳牌是在1959年提出的。Hill排序是将记录按一定的增量分组，用直接插入排序算法对每组进行排序。随着增量逐渐减小，每个组包含的关键词越来越多。当增量减少到1时，整个文件正好分成一组，算法终止。分类过程

　　Hill排序的基本思路是：将数组列在一个表中，分别插入列并排序，重复这个过程，但每次用更长的列(步长更长，列数更少)。最后，整个表只有一列。把数组转换成表格的目的是为了更好的理解这个算法，算法本身还是用数组来排序的。

　　比如，假设有这样一组数[13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10]。如果我们以步长5开始排序，我们可以通过将这个列表放在一个有5列的表中来更好地描述算法，这样它们应该是这样的(垂直元素由步长组成):

　　3 14 94 33 8225 59 94 65 2345 27 73 25 3910然后我们对每一列进行排序：

　　0 14 73 25 2313 27 94 33 3925 59 94 65 8245当上述四行数依次连在一起时，我们得到：[10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45]。这时，10已经被移动到正确的位置，然后以3:

　　0 14 7325 23 1327 94 3339 25 5994 65 8245排序后变成：

　　0 14 1325 23 3327 25 5939 65 7345 94 8294最后，按1步排序(此时，是简单的插入排序)

　　希尔对排序的分析如下：

　　具体实现代码如下：

　　shell _ sort(a list):N=len(a list)#初始步长gap=N/2 while gap 0:# Insert sort by step size for I in range(gap，N):j=I # Insert the sort while j=gap and a list[j-gap]a list[j]:a list[j-gap]，a list [j]=a list [j-gap] j-=gap #获得新的步长gap=gap/2最差时间复杂度：

　　合并是分而治之法的典型应用。排序的思想是递归分解数组，然后合并它们。

　　将数组分解到最小值后，合并两个有序数组。基本思路是比较两个数组前面的数字，谁最小谁先取，然后对应的指针后移一位。然后比较，直到一个数组为空，最后复制另一个数组的剩余部分。

　　def merge _ sort(a list):if len(a list)=1:return num=len(a list)/2 #划分left=merge _ sort(list[:num])right=merge _ sort(list[num:])#合并return merge(left，right)def merge(left，right): l，r=0，0 result=[] while l len(left)和r len(右):if left[l]right[r]:结果。append(left[l])l=1 else:result。append(right[r])r=1个结果。追加(left[l:])结果。追加(右[r:])返回结果总结：

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。