背景:数据结构与算法是IT相关的工程师一直以来的基础考察重点,很多经典书籍都是用c++或者java来实现,出于对python编码效率的喜爱,于是取search了一下python的快排实现,发现大家写的都比较个性,也所以我也总结下自己理解的python快排实现。

:本随笔注重代码实现,如果是对快速排序无任何接触的还是先看一下相关的书籍

快速排序简介:快速排序是突破O(n^2)时间复杂度上界的排序算法,其平均情况下和最好情况是的时间复杂度都是O(nlogn),最差情况下的时间复杂度为O(n^2)(最差情况下退化为选择排序),空间复杂度为O(logn)

核心思想

  核心为 partition() 函数,该函数每调用一次,会产生两个作用:

  例子:待排序数组为[3,5,1,8,2,4],调用一次该函数后数组变为[2,1,3,8,5,4]

  直接作用:确定待排序数组上某个位置的值(我们称这个值为枢轴);在上例中表现为确定了待排序数组中索引为2(第3个元素)的值,元素'3'即为枢轴的值

  副作用:将待排序数据分为了3个部分,即 [小于等于枢轴的待排序数组]+枢轴+[大于等于枢轴的待排序数组],副作用的贡献体现在减少了分治的次数

快速排序=对待排序数组采用分治+递归的方法调用partition()函数

partition()函数的时间复杂度为O(n),分治+递归调用的平均时间复杂度为O(logn),所以总体相乘为O(nlogn)

python代码实现

第一种实现,partition借助额外的list,所以partition函数的空间复杂度为O(n),因为涉及分治+递归调用,递归使用的隐含栈需要O(logn)的时间复杂度,所以整体空间复杂度为O(nlogn),借助额外的数据结构一般会起到两个效果:1、降低时间复杂度 或者 2、提高代码可读性(易于理解),这里并没有降低时间复杂度

def quick_sort1(lst):
"""快速排序"""
def partition(lst, left, right):
#借助两个临时列表存放小于枢轴的元素和大于枢轴的元素
l_list, r_list = [], []
#选取待排序列表的最左元素作为枢轴
pivot_value = lst[left]
for i in lst[left+1:right+1]:
if i<=pivot_value:
l_list.append(i)
else:
r_list.append(i)
#因为是原地排序,所以对原待排序数组的相应元素进行替换
lst[left:right+1] = l_list+[pivot_value]+r_list
return left+len(l_list) def q_sort(lst, left, right):
"""辅助函数,便于递归调用"""
if left>=right:
return
pivot_key = partition(lst, left, right)
q_sort(lst, left, pivot_key-1)
q_sort(lst, pivot_key+1, right) if not lst or len(lst)==0:
return lst q_sort(lst, 0, len(lst)-1) return lst

上述实现采用了额外的list,虽然增加了可读性,但是提高了空间复杂度,所以,可以对其优化,将partition函数的空间复杂度降为O(1)

第二种实现,不借助额外列表

def quick_sort2(lst):
"""快速排序"""
def partition(lst, left, right):
#默认选择列表最左元素作为枢轴
pivot_value = lst[left]
while left<right:
while left<right and lst[right]>=pivot_value:
right-=1
#当右指针对应元素小于枢轴的值,将左右指针对应元素交换,使小于枢轴的值位于枢轴的左侧
lst[left], lst[right] = lst[right], lst[left]
while left<right and lst[left]<=pivot_value:
left+=1
#当左指针对应元素大于枢轴的值,将左右指针对应元素交换,使大于枢轴的值位于枢轴的右侧
lst[left], lst[right] = lst[right], lst[left]
return left def q_sort(lst, left, right):
if left>=right:
return
pivot_key = partition(lst, left, right)
q_sort(lst, left, pivot_key-1)
q_sort(lst, pivot_key+1, right) if not lst or len(lst)==0:
return lst q_sort(lst, 0, len(lst)-1) return lst

这里通过元素交换的方式达到了与方法1同样的效果,所以在很多资料上,快速排序和冒泡排序都被分类为'交换排序',但有一点要注意,快速排序最差的情况下,会退化为选择排序而非冒泡排序

针对第二种情况,我们还可以继续优化,省去不必要的交换,将"交换"优化为“替换”

第三种实现

def quick_sort3(lst):
"""快速排序"""
def partition(lst, left, right):
#默认选择列表最左元素作为枢轴,同时也记录了left最初对应的元素值
pivot_value = lst[left]
while left<right:
while left<right and lst[right]>=pivot_value:
right-=1
#将left对应的元素替换为right(小于枢轴)对应的元素
lst[left] = lst[right]
while left<right and lst[left]<=pivot_value:
left+=1
#将right对应的元素替换为left(大于枢轴)对应的元素
lst[right] = lst[left]
#当left和right相等时,使用最初记录的left对应的元素值替换当前指针的元素
lst[left] = pivot_value
#返回枢轴对应的索引
return left def q_sort(lst, left, right):
if left>=right:
return
pivot_key = partition(lst, left, right)
q_sort(lst, left, pivot_key-1)
q_sort(lst, pivot_key+1, right) if not lst or len(lst)==0:
return lst q_sort(lst, 0, len(lst)-1) return lst

第三种方案和前两种一样,都是将列表的最左元素作为枢轴,这也是导致快速排序最差情况时间复杂度为O(n^2)的原因,比如每次列表的最左元素都为最大值或者最小值,那每次对partition函数的调用只起到了直接作用(确定了列表的最左端的最小值或者最右端的最大值),而没有起到副作用(副作用的目的是减小分治次数)

所以我们可以对枢轴的选取进行优化,优化的目的是使枢轴的选取避开最大值或最小值,尽量靠近中位数,优化的思路有两种

1、随机选取

2、选取列表中left, right, (left+right)//2,三个索引位置对应元素居中的元素

由于随机数的生成在编程语言API中的实现也要耗费一定的时间复杂度,所以我们选择2

第四种实现如下

def quick_sort4(lst):
"""快速排序"""
def partition(lst, left, right):
#计算中间索引
mid = (left+right)//2
#将三个元素中大小居中的元素交换至列表的最左侧
if lst[left]>lst[mid]:
lst[left], lst[mid] = lst[mid], lst[left]
if lst[mid]>lst[right]:
lst[mid], lst[right] = lst[right], lst[mid]
if lst[left]<lst[mid]:
lst[left], lst[mid] = lst[mid],lst[left] pivot_value = lst[left]
while left<right:
while left<right and lst[right]>=pivot_value:
right-=1
lst[left] = lst[right]
while left<right and lst[left]<=pivot_value:
left+=1
lst[right] = lst[left]
lst[left] = pivot_value
return left def q_sort(lst, left, right):
if left>=right:
return
pivot_key = partition(lst, left, right)
q_sort(lst, left, pivot_key-1)
q_sort(lst, pivot_key+1, right) if not lst or len(lst)==0:
return lst q_sort(lst, 0, len(lst)-1) return lst

经过2~4的优化,我们已经

1)把空间复杂度由O(nlogn)降至O(n),yi

2)并尽量优化了最差情况下的时间复杂度,使其比O(n^2)要好一些

但需要提醒一下,其最佳情况下的时间复杂度依旧使O(nlogn),而一些简单排序算法,如插入排序和优化后的冒泡排序的最优时间复杂度都可以达到O(n)

快排在面对大量数据排序时表现良好,

所以可以进行优化,当待排序数据的元素数量小于某个常数值时采用插入排序,否则使用快速排序

第五种实现

def quick_sort5(lst):
"""快速排序"""
def partition(lst, left, right):
#计算中间索引
mid = (left+right)//2
#将三个元素中大小居中的元素交换至列表的最左侧
if lst[left]>lst[mid]:
lst[left], lst[mid] = lst[mid], lst[left]
if lst[mid]>lst[right]:
lst[mid], lst[right] = lst[right], lst[mid]
if lst[left]<lst[mid]:
lst[left], lst[mid] = lst[mid],lst[left] pivot_value = lst[left]
while left<right:
while left<right and lst[right]>=pivot_value:
right-=1
lst[left] = lst[right]
while left<right and lst[left]<=pivot_value:
left+=1
lst[right] = lst[left]
lst[left] = pivot_value
return left def q_sort(lst, left, right):
if left>=right:
return
pivot_key = partition(lst, left, right)
q_sort(lst, left, pivot_key-1)
q_sort(lst, pivot_key+1, right) if not lst or len(lst)==0:
return lst
#取某个常数,待排序元素数量大于该常数时使用快排,否则使用插入排序
if len(lst)>50:
q_sort(lst, 0, len(lst)-1)
else:
#插入排序在此不实现了,大家自行解决
insert_sort(lst) return lst

经过上述优化,我们做到了

1)空间复杂度由O(nlogn)优化至O(logn)

2)  将最差情况下的时间复杂度O(n^2)尽可能提升

3)将时间复杂度的下界提升至O(n),当然,这已经不是单纯的快排了- -!

刚开始写博客,有不对的地方还望指教~~~

快速排序python实现总结的更多相关文章

  1. 快速排序--Python实现

    快速排序算法:1.选择一个基准数2.小于基准数的放左边,大于基准数的放右边3.利用递归的方法针对左边的数据进行快速排序,再对右边的数据进行快速排序4.递归停止的条件:数组为空或者只有一个元素 时间复杂 ...

  2. 快速排序python实现

    #--×--coding:utf-8-*- def main(): nlist = [] while 1: tmp = raw_input("Please input your elemen ...

  3. 快速排序(python版)

    #!coding:utf8 def quicksort(list_num, left, right): if left > right: return low = left high = rig ...

  4. 快速排序-python

  5. python数据结构与算法

    最近忙着准备各种笔试的东西,主要看什么数据结构啊,算法啦,balahbalah啊,以前一直就没看过这些,就挑了本简单的<啊哈算法>入门,不过里面的数据结构和算法都是用C语言写的,而自己对p ...

  6. 常见排序算法-Python实现

    常见排序算法-Python实现 python 排序 算法 1.二分法     python    32行 right = length-  :  ]   ):  test_list = [,,,,,, ...

  7. python实现简单排序算法

    算法 递归两个特点: 调用自身 有穷调用 计算规模越来越小,直至最后结束 用装饰器修饰一个递归函数时会出现问题,这个问题产生的原因是递归的函数也不停的使用装饰器.解决方法是,只让装饰器调用一次即可,那 ...

  8. <算法图解>读书笔记:第4章 快速排序

    第4章 快速排序 4.1 分而治之 "分而治之"( Divide and conquer)方法(又称"分治术") ,是有效算法设计中普遍采用的一种技术. 所谓& ...

  9. Python和Java的语法对比,语法简洁上python的确完美胜出

    Python是一种广泛使用的解释型.高级编程.通用型编程语言,由吉多·范罗苏姆创造,第一版发布于1991年.可以视之为一种改良(加入一些其他编程语言的优点,如面向对象)的LISP.Python的设计哲 ...

随机推荐

  1. Estimating Gene Frequencies| method of maximum likelihood|point estimate

    I.11 Estimating Gene Frequencies 在小样本上计算基因A的概率PA,举例如下: 通过加大样本会将通过观察值得到的数趋近于真实数据,所以该问题转化为了统计学上利用大量观察值 ...

  2. Python的lambda学习

    lambda可以简化简单循环,如下: def fc1(x): return x + 10 print "fc1(23) = ", fc1(23) y = lambda x: x+1 ...

  3. 进程异常行为-反弹Shell攻击,KILL多个进程

    进程异常行为-反弹Shell攻击 父进程名称:bash 进程名称:bash 进程名称:/usr/bin/bash 进程id:23,077 命令行参数:sh -c /bin/bash -i >&a ...

  4. fcntl()函数之非阻塞模型

    优点:设置标准输入为非阻塞(有数据则读 没有数据则立即返回),常用于网络通信以及轻量信息多并发中 步骤: 1.oldflag=fcntl(STDIN_FILENO,F_GETFL); 获取标准输入的文 ...

  5. 《C程序设计语言》练习 1-6,1-7

    #include<stdio.h> /*验证表达式getchar()!=EOF的值是0还是1*/ main () { int c; c=getchar()!=EOF; printf(&qu ...

  6. python语法基础-基础-变量和数据类型

    ###############   第一个python程序   ############### print("hello python") # 打印hello python # 分 ...

  7. JSON — Java与JSON数据互转

    转换时Bean所要求的: 被转换的Bean必需是public的. Bean被转换的属性一定要有对应的get方法,且一定要是public的. Bean中不能用引用自身的this的属性,否则运行时出现et ...

  8. getHibernateTemplate()的find用法大全

    一.find(String queryString); 示例:this.getHibernateTemplate().find("from bean.User"); 返回所有Use ...

  9. 16)用了session会话技术

    为什么用session会话技术? 因为假如你进入后台,不可能随意进入,即使你的验证通过了,那么还需要一个变量来存一个标志,假如标志的值是yes,那么我们可以直接进入后台的首页,无需验证,但是,标志是n ...

  10. LeetCode Day 8

    LeetCode0015 给定一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?找出所有满足条件且不重复的三元组. 例如, 给 ...