python 幾種快速排序的實現以及執行時間比較

2022-06-11 20:30:18 字數 3989 閱讀 8288

快速排序的基本思想：首先選定乙個陣列中的乙個初始值，將陣列中比該值小的放在左邊，比該值大的放在右邊，然後分別對左邊的陣列進行如上的操作，對右邊的陣列進行如上的操作。（分治+遞迴）

1.利用匿名函式lambda

匿名函式的基本用法func_name  = lambda x:array，冒號左邊的x代表傳入的引數，冒號右邊的array代表返回值，當然名字是可以自己取的。

quick_sort = lambda


array: \


array 


if len(array) <= 1\


else quick_sort([item for item in array[1:] if item <=array[0]]) \


+ [array[0]] +\


quick_sort([item 


for item in array[1:] if item > array[0]])
2.將匿名函式拆解封裝為函式

def


func2(array):


if len(array)<=1:


return


array


tmp =array[0]


left = [x for x in array[1:] if x<=tmp]


right = [x for x in array[1:] if x>tmp]


return func2(left) + [tmp] + func2(right)
3.網上常見的

def


func2(array,left,right):


if left>=right:


return


low=left


high=right


tmp=array[low]


while left


while leftand array[right]>tmp:


right-=1array[left] =array[right]


while leftand array[left]<=tmp:


left+=1array[right]=array[left]


array[right]=tmp


func2(array,low,left-1)


func2(array,left+1,high)
4.演算法導論裡面的

def


func3(array, l, r):


if l 


q =partition(array, l, r)


func3(array, l, q - 1)


func3(array, q + 1, r)


defpartition(array, l, r):


x =array[r]


i = l - 1


for j in


range(l, r):


if array[j] <=x:


i += 1array[i], array[j] =array[j], array[i]


array[i + 1], array[r] = array[r], array[i + 1]


return i + 1
5.利用棧實現非遞迴版本

def


func4(array, l, r):


if l >=r:


return


stack =


while


stack:


low =stack.pop(0)


high =stack.pop(0)


if high - low <=0:


continue


x =array[high]


i = low - 1


for j in


range(low, high):


if array[j] <=x:


i += 1array[i], array[j] =array[j], array[i]


array[i + 1], array[high] = array[high], array[i + 1]


stack.extend([low, i, i + 2, high])
6.python內建的

sorted(array)
本來是想利用裝飾器來測一下每個函式的執行時間的，但是由於快排裡面存在遞迴，使用裝飾器會報錯，就只好乙個個計算了。這裡還是貼一下用裝飾器計算時間的**：

def


count_time(func):


@wraps(func)


def helper(func,*args,**kwargs):


start=time()


result = func(*args,**kwargs)


end=time()


print("


函式：", func.__name__, "


", round(end - start, 4), "s"


)        


return


result


return helper



from functools import


wraps


from random import


randint


from time import


time


func1_start =time()


res =quick_sort(array)


func1_end =time()


print("


", round(func1_end - func1_start, 4), "s"


)func2_start =time()


func2(array)


func2_end =time()


print("


", round(func2_end - func2_start, 4), "s"


)func3_start =time()


func3(array,0,len(array)-1)


func3_end =time()


print("


", round(func3_end - func3_start, 4), "s"


)func4_start =time()


func4(array,0,len(array)-1)


func4_end =time()


print("


", round(func4_end - func4_start, 4), "s"


)func5_start =time()


func5(array,0,len(array)-1)


func5_end =time()


print("


", round(func5_end - func5_start, 4), "s"


)func6_start =time()


sorted(array)


func6_end =time()


print("


", round(func6_end - func6_start, 4), "


s")
輸入array的定義：

array = [randint(0,100) for i in range(5000)]
需要注意的是，隨著資料量的增加，方法4，也就是演算法導論中的會出現以下問題：

這是因為python中的遞迴深度是有一定限制的，可以使用如下方法暫時解決該問題：

import


syssys.setrecursionlimit(100000)
同時，方法4還會出現記憶體溢位問題，方法4也太坑了。

總結：

快速排序演算法的幾種實現

序列範圍 l,u 選取第乙個元素為樞紐值，然後圍繞t劃分陣列 m a 1 for i a,b if x i 迴圈終止後有 此時交換x l 和x m 即可。void qsort1 int x,int l,int u swap x l x m qsort x,l,m 1 qsort x,m 1,u 可以...

快速排序的實現（python）

usr bin env python3 coding utf 8 import random 快速排序基礎 defpartition a,p,r x a r i p 1 j p while j r if a j x i 1 temp a i a i a j a j temp j 1 i 1 temp...

快速排序的python實現

執行過程中,i 之前 含 的元素都比 a r 小,之後的比 a r 大。即 p i 的元素比 a r 小,其後a i 1 a j 1 的元素比a r 大。最後,交換a i 1 與a r def quicksort a,p,r if p r q partition a,p,r quicksort a,...