Python 实现快排

快速排序简介
快速排序,又称划分交换排序,从无序队列中挑取一个元素,把无序队列分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
简单来说:挑元素、划分组、分组重复前两步

快速排序原理示意图
通过上面对快速排序的简介,我们知道了,快速排序主要包括以下两方面:
挑元素划分组、整体递归分组
挑元素划分组示意图:

特点:
1、因为是无序队列,所以位置可以随机挑
2、临时划分一个空间,存放我们挑选出来的中间元素
3、左标签位置空,移动右标签,反之一样
4、重复3,直到左右侧标签指向同一个位置,
5、把临时存放的中间元素,归位
一句话:左手右手一个慢动作,右手左手慢动作重播

整体划分示意图:

特点:
1、递归拆分
2、拆分到最后,所有小组内的元素个数都是1
一句话:递归拆分到不能再拆

代码实践分析
根据上面两个示意图的分析,我们要从两个大方面分析:
序列切割 和 递归拆分

1、序列切割
序列切割这个知识点,我们从四个方面分别介绍:
3个基本标签、右侧推进、左侧推进、停止推进(即元素归位)

1.1、3个基本标签
大小区域切割,至少涉及到三个标签:
mid:指定要切割的临时中间数字    
left:从队列左侧推进的标签
right:从队列右侧推进的标签                                     

 1 def quick_sort(li, start, end):
 2     # 分治 一分为二
 3     # start=end ,证明要处理的数据只有一个
 4     # start>end ,证明右边没有数据
 5     if start >= end:
 6         return
 7     # 定义两个游标,分别指向0和末尾位置
 8     left = start
 9     right = end
10     # 把0位置的数据,认为是中间值
11     mid = li[left]
12     while left < right:
13         # 让右边游标往左移动,目的是找到小于mid的值,放到left游标位置
14         while left < right and li[right] >= mid:
15             right -= 1
16         li[left] = li[right]
17         # 让左边游标往右移动,目的是找到大于mid的值,放到right游标位置
18         while left < right and li[left] < mid:
19             left += 1
20         li[right] = li[left]
21     # while结束后,把mid放到中间位置,left=right
22     li[left] = mid
23     # 递归处理左边的数据
24     quick_sort(li, start, left-1)
25     # 递归处理右边的数据
26     quick_sort(li, left+1, end)
27
28 if __name__ == ‘__main__‘:
29     l = [6,5,4,3,2,1]
30     # l = 3 [2,1,5,6,5,4]
31     # [2, 1, 5, 6, 5, 4]
32     quick_sort(l,0,len(l)-1)
33     print(l)
34     # 稳定性:不稳定
35     # 最优时间复杂度:O(nlogn)
36     # 最坏时间复杂度:O(n^2)

关键点:
序列切割:
1、挑中间元素:mid = alist[start]
2、右推进:while right > left and alist[right] >= mid:
3、左推进:while left < right and alist[left] < mid:
4、推进循环:while left < right:
5、元素归位:alist[left] = mid
递归拆分:
1、小组边界确定:left = start、right = end
2、递归退出条件:if start < end:
3、函数自调用:quick_sort(alist, start, end)

时间复杂度
最优时间复杂度:O(nlogn)
对于每次快排,left和right的标签分别在左右两册数据全部都移动了一遍,相当于遍历了所有数据,那么时间复杂度是O(n)
因为涉及到了递归分组,所以他的时间复杂度是O(logn)
整体来说:最优的时间复杂度是 O(nlogn)

最坏时间复杂度:O(n2)

因为递归分组分组的条件不一定是二分,有可能每一次mid指定的都是最大或者最小,那么有多少个元素,我们就可能分多少次组,这种情况时间复杂度就是O(n)了
所以最坏的时间复杂度就是O(n2),那么最坏也不过如此了。
稳定性:不稳定

思考:
改哪个地方,结果是降序?
while right > left and alist[right] >= mid:     代码中的 >= 改为 <=
while left < right and alist[left] < mid         代码中的 < 改为 >
本节内容小结:
1、快速排序原理:挑元素、划分组,分组重复前两步。
2、快速排序实践步骤:
划分组:准备工作+左右移动+元素归位
递归:函数自调用+退出条件

原文地址:https://www.cnblogs.com/kaiping23/p/9614395.html

时间: 2024-08-03 10:49:36

Python 实现快排的相关文章

Python的快排应有的样子

快排算法 ? 简单来说就是定一个位置然后,然后把比它小的数放左边,比他大的数放右边,这显然是一个递归的定义,根据这个思路很容易可以写出快排的代码 ? 快排是我学ACM路上第一个让我记住的代码,印象很深刻,以前学的是Pascal,写这个要写好长一串,但是因为和归并排序比起来还算短的,也就背下来了.好奇的我点开百科看python的快排代码,就看到了如下代码: #quick sort def quickSort(L, low, high): i = low j = high if i >= j: re

觉得python写快排真的简单易懂

记录下自己学习python的学习路 快速排序: def mySort(l): if len(l)<2:#如果列表中只有一个元素就会返回 return l num=l[0]#拿一个元素作为参考元素 startl=[x for x in l[1:] if x <= num ]#使用列表推导式把小于等于参考元素的放入新的列表 endl=[x for x in l[1:] if x > num ]#使用列表推导式把大于参考元素的放入新的列表 #使用递归的方式将排序好的元素拼接为新的列表返回 re

【Python实现快排】 -- 2019-08-09 12:12:36

原文: http://106.13.73.98/__/117/ 挖坑法思路: 取一个元素p(第一个元素),使元素p归位: 列表被p分成两部分,左边的数一定不大于p,右边的数一定不小于p: 递归完成排序. Python代码示例: lst = [5, 7, 4, 3, 1, 2, 9, 8] def quick_sort(d, l, r): if l < r: m = partition(d, l, r) quick_sort(d, l, m - 1) quick_sort(d, m + 1, r)

【Python实现快排】 &#202465;

原文: http://blog.gqylpy.com/gqy/342 " 挖坑法思路: 取一个元素p(第一个元素),使元素p归位: 列表被p分成两部分,左边的数一定不大于p,右边的数一定不小于p: 递归完成排序. Python代码示例: lst = [5, 7, 4, 3, 1, 2, 9, 8] def quick_sort(d, l, r): if l < r: m = partition(d, l, r) quick_sort(d, l, m - 1) quick_sort(d, m

Python随笔-快排

def swap(arr, i, j): temp = arr[i] arr[i] = arr[j] arr[j] = temp def part(arr, beg, end): if end - beg <= 0: return beg v = arr[beg] idx = beg + 1 for x in range(beg+1, end+1): if(arr[x] < v): swap(arr, idx, x) idx += 1 swap(arr, idx-1, beg) return

python 冒泡和快排,不多说【无聊】

1 #-*-coding:utf8-*- 2 import random 3 a=[] 4 b=[] 5 def init_array(): 6 for i in range(10000): 7 v = random.randint(1,10000) 8 a.append(v) 9 b.append(v) 10 11 #冒泡 12 def sort_array(a): 13 for i in range(len(a)): 14 for j in range(i+1,len(a)): 15 if

Python实现排序(冒泡、快排、归并)

Thomas H.Cormen 的<算法导论>上介绍的几个经典排序算法的Python实现. 1.冒泡排序: 简单的两重循环遍历,使最小(最大)的值不断地往上升(下沉)而实现的排序,算法时间为O(n2). 代码如下: 1 def up_sort(a): 2 # 冒泡排序 3 4 a_length = len(a) 5 while True: 6 i = 0 7 j = 1 8 9 while True: 10 if a[i] > a[j]: 11 a[i], a[j] = a[j], a[

python 版 quicksort 快排

今天看了下苹果xml 解析,写了个小demo 心想还是 在博客上写点东西吧,毕竟很久很久都没有上来了 先上个效果图把 接下来 看下 工程目录图吧 本demo 分两种解析模式,一是苹果自带的, 首先先看下苹果自带的吧,工程文件为 NoteXMLParser 文件 ,另一种解析模式 是 NotesTBXMLParser文件 NoteXMLParser.h 文件代码如下 : // // NoteXMLParser.h // TestXML // // Created by choni on 14-5-

用python写个快排

快排过程比较简单就直接上代码了: 1 #!/usr/bin/python3 2 3 def quik_sort(L, left, right): 4 if left <= right: 5 key = L[left] 6 i = left 7 j = right 8 while i < j: 9 while i < j and key <= L[j]: 10 j -= 1 11 L[i] = L[j] 12 while i < j and L[i] <= key: 13