python实现排序_排序(python)

快速排序的介绍

快速排序的Python实现

快速排序的介绍

快速排序(quick sort)的采用了分治的策略。

分治策略指的是：

将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

快排的基本思想是：

在序列中找一个划分值，通过一趟排序将未排序的序列排序成 独立的两个部分，其中左边部分序列都比划分值小，右边部分的序列比划分值大，此时划分值的位置已确认，然后再对这两个序列按照同样的方法进行排序，从而达到整个序列都有序的目的。

基准值若能把数据分为平均的两块，划分次数O(logn)，每次划分遍历比较一遍O(n)，时间复杂度O(nlogn)。

额外空间开销出在暂存基准值，O(logn)次划分需要O(logn)个，空间复杂度O(logn)

快速排序的Python实现

主要体现在以下方面：

分组基准的选取过于随便，不一定可以取到列表的中间值

空间复杂度大，使用了两个列表解析式，而且每次选取进行比较时需要遍历整个序列。

若序列长度过于小(比如只有几个元素)，快排效率就不如插入排序了。

递归影响性能，最好进行优化。

下面用Python写一个C风格的快排(这里可以体会到快排的精髓)：

defquick_sort(L):return q_sort(L, 0, len(L) - 1)defq_sort(L, left, right):if left

pivot=Partition(L, left, right)

q_sort(L, left, pivot- 1)

q_sort(L, pivot+ 1, right)returnLdefPartition(L, left, right):

pivotkey=L[left]while left =pivotkey:

right-= 1L[left]=L[right]while left < right and L[left] <=pivotkey:

left+= 1L[right]=L[left]

L[left]=pivotkeyreturnleft

L= [5, 9, 1, 11, 6, 7, 2, 4]print quick_sort(L)

快速排序需要提供三个参数：待排序序列 、序列最小下标值left、序列最大下标值right。让用户提供这三个参数很麻烦。这里写个函数进行封装：

defquick_sort(L):return q_sort(L, 0, len(L) - 1)

下面看一下q_sort函数：

defq_sort(L, left, right):if left

pivot=Partition(L, left, right)

q_sort(L, left, pivot- 1)

q_sort(L, pivot+ 1, right)return L

这个函数的核心是pivot = Partition(L, left, right)，在执行它之前，列表的值为[5, 9, 1, 11, 6, 7, 2, 4]，而Partition函数做的事情是找到一个分组标准，然后进行分组，让它左边的值比它小，右边的值比它大。

在经过Partition函数分组后，列表变为[4, 2, 1, 5, 6, 7, 11, 9]，并把5的下标值(也就是3)返回给pivot，此时列表变成两个小列表[4, 2, 1]和[5, 6, 7, 11, 9] ，之后调用q_sort，就是调用q_sort(L,0, 2)和q_sort(L, 4 ,7)，对其进行Partition操作，直到整个列表有序为止。

下面看看关键的Partition函数是如何做的：

defPartition(L, left, right):

pivotkey=L[left]while left =pivotkey:

right-= 1L[left]=L[right]while left < right and L[left] <=pivotkey:

left+= 1L[right]=L[left]

L[left]=pivotkeyreturn left

以一趟排序为例[5, 9, 1, 11, 6, 7, 2, 4]：

开始排序时，left=0，right=7，首先用表的第一个下标值作为 分组关键字pivot，

第一趟排序过程

进行while left < right and L[right] >= pivotkey:判断，其中L[right]=4 不满足条件，跳出循环，执行L[left] = L[right]，执行后列表变成：

第一趟排序结果

然后进行while left < right and L[left] <= pivotkey:，L[left] = 4 <= 5，条件成立，left向右边移动，然后L[left] = 9 不满足条件，执行L[right] = L[left]，执行后列表变为：

第一趟排序过程

然后进行while left < right判断，条件成立，继续进行判断while left < right and L[right] >= pivotkey:，L[right] = 9，满足条件，right向左移动1，继续判断，不满足条件，执行L[left] = L[right]，执行后列表变为：

第一趟排序过程

然后进行while left < right and L[left] <= pivotkey:判断，L[left] = 2,满足条件，left向右移动，然后L[left] = 1，满足条件，left向右移动，L[left] = 11，不满足条件，执行L[right] = L[left]，执行后列表变为：

第一趟排序过程

然后进行while left < right 判断，条件成立，继续进行判断：while left < right and L[right] >= pivotkey:，满足条件，right向左移动，一直移动到这样的状态：

第一趟排序过程

此时不满足条件：left < right，跳出循环。然后执行L[left] = pivotkey，并返回left下标值。此时序列变为:

第一趟结束

接下来就是用递归分别对子列表进行排序。读者可以自己试试。

来源链接：https://www.jianshu.com/p/2b2f1f79984e

#完整代码

defquick_sort1(L):return q_sort(L,0,len(L)-1)#起到分区作用

defq_sort(L,left,right):if left

pivot=Partition(L,left,right)#递归解决

q_sort(L,left,pivot-1)

q_sort(L,pivot+1,right)returnL#对区间选取第一个数作为pivotkey，进行划分区间

defPartition(L,left,right):#选取第一个元素

pivotkey=L[left]#退出条件根据当前pivotkey以确定其的左右区间，即left==right

while left

while left=pivotkey:

right-=1

#找到元素比当前pivotkey小，则对left位置的值进行替换(将right索引对应取值对left索引对应取值进行替换，)(1.第一次的left取值为pivotkey)

L[left]=L[right]#从left索引开始，依次判断当前元素L[left]是否比pivotkey小，如比pivotkey大，则left索引往前右移。

while left

left+=1

#找到元素，替换

L[right]=L[left]#对上述流程总有两个位置的元素是相等的，因而在left==right的时候，对left的位置进行赋值pivotkey。

L[left]=pivotkeyreturn left

归并排序：

有两种类型，一种递归和迭代，递归法的核心思想是把列表分解为两个子列表，单独排序子列表在合并子列表。你可以将他理解为一个二分树，其列表为根节点，，子列表为子节点。首先对子列表进行排序，然后进行归并子列表

迭代主要思想。将列表看成一个n个长度为1的子列表。然后，利用循环把相邻的两个子列表排序合并。然后可以得到n/2长度为2的子列表。之后，依次利用循环进行相邻的两个列表进行合并。最后得到一二长度为n的列表。想过程想象成一个倒二叉树，对独立的子列表进行多次得带，知道到达跟部。

归并排序划分子问题采用二分法，共需O(logn)次划分，当然需要相当次合并；每次合并遍历比较O(n)。时间复杂度O(nlogn)。

额外空间开销出在合并过程中的一个暂存数组，空间复杂度O(n)。

#递归

def mergeSort(myList): #传入参数myList

if len(myList)<2: #如果myList只有一个元素即停止

return

cut=len(myList)//2 #找到数据的二分点

listA=myList[:cut] #左子列表

listB=myList[cut:] #右子列表

mergeSort(listA) #将左子列表递归排序

mergeSort(listB)

#print(listA,listB)

pointerA=0 #指针A

pointerB=0 #指针B

counter=0 #排序后元素的位置

while pointerA

if listA[pointerA]

myList[counter]=listA[pointerA]

pointerA+=1

else:

myList[counter]=listB[pointerB]

pointerB+=1

counter+=1

while pointerA

myList[counter]=listA[pointerA]

pointerA+=1

counter+=1

while pointerB < len(listB):

myList[counter] = listB[pointerB]

pointerB += 1

counter += 1

#例子

myList=[23,5,2,8,21,3,4,11,19]

mergeSort(myList)print(myList)

输出结果：

[23] [5]

[2] [8]

[5, 23] [2, 8]

[21] [3]

[11] [19]

[4] [11, 19]

[3, 21] [4, 11, 19]

[2, 5, 8, 23] [3, 4, 11, 19, 21]

[2, 3, 4, 5, 8, 11, 19, 21, 23]

迭代实现

#迭代实现

defmergeSort(mList):

length=len(mList)#n为子数组长度，当n等于length时，即数组合并完成

n=1

while n

for i in range(0,length,n*2):

listA=mList[i:i+n]

listB=mList[i+n:i+n*2]

#print(listA,listB)#指针A

pointerA=0#指针B

pointerB=0#排序后元素的位置

counter=iwhile pointerA

mList[counter]=listA[pointerA]

pointerA+=1

else:

mList[counter]=listB[pointerB]

pointerB+=1counter+=1

while pointerA

mList[counter]=listA[pointerA]

counter+=1pointerA+=1

while pointerB

mList[counter]=listB[pointerB]

counter+=1pointerB+=1

#一轮合并后子数组的长度是成倍增长

n=n*2

myList=[6,3,-2,0,-1,5,9,7]

mergeSort(myList)print(myList)

#运行结果

[6] [3]

[-2] [0]

[-1] [5]

[9] [7]

[3, 6] [-2, 0]

[-1, 5] [7, 9]

[-2, 0, 3, 6] [-1, 5, 7, 9]

[-2, -1, 0, 3, 5, 6, 7, 9]

递归第一步排序左子列表，第二步排序右子列表，迭代法每一步都排序所有的子列表，两者的时间复杂度是一样的。