❶ 怎麼用python編quicksort程序
快速排序的原理：在已知的數列中選擇一個數字作為基準，與剩餘的數作比較，將比這個基準小的數放在左邊，比其大的數放在右邊；然後將基準左右兩邊的數列重復以上步驟，直到基準兩邊只有一個數字為止；
特點：不穩定，時間復雜度最理想 O(nlogn) 最差時間O(n^2)
演算法原理比較簡單，易於理解，其實現方法也較為多種，這里我們使用遞歸調用的思想採用Python實現代碼；
[python]view plain
defquickSort(num,l,r):
ifl>=r:#如果只有一個數字時，結束遞歸
return
flag=l#是L不是1
foriinrange(l+1,r+1):#以第一個數字作為基準，從第二個數開始比較
ifnum[flag]>num[i]:
tmp=num[i]
delnum[i]
num.insert(flag,tmp)
flag+=1
quickSort(num,l,flag-1)#將基準的前後部分分別遞歸排序
quickSort(num,flag+1,r)
num=[1,-9,5,7,9,3,2,8]
quickSort(num,0,7)
printnum
[-9,1,2,3,5,7,8,9]
❷ python 快速排序實現的具體代碼，以及講解。我是小白還請講清楚一點，謝謝了。
快速排序：在數組L中選一個數叫支點Pivot，把數組L中所有比支點小的數放在支點的左邊；比支點大的數放在支點右邊..；然後分別對左、右兩個新數組重新各選一個支點，重復之前的排法，直到左、右只剩下一個數不用再分。經過這樣的過程後，整個數組L就被從小到大排好了.
qsort()是排序的實現。qsort(數組，起點序號，終點序號)；內容是由partition分好一輪後再分別排左、右子數組。
partition()是選支點，並分配數給左右和區分左右的過程。
❸ python怎麼快速排序與查找
演算法體現的是一個思想，就像這里體現的是一個"分而治之"的思想，只要思想不山寨，一些小細節其實不要太在意。學演算法嘛，就學個處理問題的思想。不過真正的快排演算法不是這樣的，真正最優的快排要求隨機選擇主元加原址排序。我這里兩樣都沒做到。但是我還是認為他是個快排演算法，因為他的思想就是快排的思想。
很多時候研究演算法去爭論代碼量的多少真的沒有這個必要。
❹ Python實現的快速排序演算法詳解
Python實現的快速排序演算法詳解
本文實例講述了Python實現的快速排序演算法。分享給大家供大家參考，具體如下：
快速排序基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
如序列[6，8，1，4，3，9]，選擇6作為基準數。從右向左掃描，尋找比基準數小的數字為3，交換6和3的位置，[3，8，1，4，6，9]，接著從左向右掃描，尋找比基準數大的數字為8，交換6和8的位置，[3，6，1，4，8，9]。重復上述過程，直到基準數左邊的數字都比其小，右邊的數字都比其大。然後分別對基準數左邊和右邊的序列遞歸進行上述方法。
實現代碼如下：
def parttion(v, left, right):
key = v[left]
low = left
high = right
while low < high:
while (low < high) and (v[high] >= key):
high -= 1
v[low] = v[high]
while (low < high) and (v[low] <= key):
low += 1
v[high] = v[low]
v[low] = key
return low
def quicksort(v, left, right):
if left < right:
p = parttion(v, left, right)
quicksort(v, left, p-1)
quicksort(v, p+1, right)
return v
s = [6, 8, 1, 4, 3, 9, 5, 4, 11, 2, 2, 15, 6]
print("before sort:",s)
s1 = quicksort(s, left = 0, right = len(s) - 1)
print("after sort:",s1)
運行結果：
before sort: [6, 8, 1, 4, 3, 9, 5, 4, 11, 2, 2, 15, 6]
after sort: [1, 2, 2, 3, 4, 4, 5, 6, 6, 8, 9, 11, 15]
❺ 求助幫忙看一下用python實現快速排序的代碼為什麼一直無限循環了應該怎麼修改呢
非常簡單，就把第一個if left > right 改成 left >= right就可以了。。
當left = right的時候也應該是退出的條件，你沒有加上所以就陷入了while != j這個循環裡面了。。
在這個裡面 left = right =j,而i=left+1=j+1，所以i>j,而你的判斷條件只有i<j的，所以兩個while和一個if都不滿足就一直死循環了。。
❻ 快速排序python實現
def quick_sort(nums: list, left: int, right: int) -> None:
if left < right:
i = left
j = right
# 取第一個元素為樞軸量
pivot = nums[left]
while i != j:
# 交替掃描和交換
# 從右往左找到第一個比樞軸量小的元素，交換位置
while j > i and nums[j] > pivot:
j -= 1
if j > i:
# 如果找到了，進行元素交換
nums[i] = nums[j]
i += 1
# 從左往右找到第一個比樞軸量大的元素，交換位置
while i < j and nums[i] < pivot:
i += 1
if i < j:
nums[j] = nums[i]
j -= 1
# 至此完成一趟快速排序，樞軸量的位置已經確定好了，就在i位置上（i和j)值相等
nums[i] = pivot
# 以i為樞軸進行子序列元素交換
quick_sort(nums, left, i-1)
quick_sort(nums, i+1, right)
# 測試代碼
import random
data = [random.randint(-100, 100) for _ in range(10)]
quick_sort(data, 0, len(data) - 1)
print(data)
❼ Python實現的幾個常用排序演算法實例
#encoding=utf-8
importrandom
fromimport
defdirectInsertSort(seq):
"""直接插入排序"""
size=len(seq)
foriinrange(1,size):
tmp,j=seq[i],i
whilej>0andtmp<seq[j-1]:
seq[j],j=seq[j-1],j-1
seq[j]=tmp
returnseq
defdirectSelectSort(seq):
"""直接選擇排序"""
size=len(seq)
foriinrange(0,size-1):
k=i;j=i+1
whilej<size:
ifseq[j]<seq[k]:
k=j
j+=1
seq[i],seq[k]=seq[k],seq[i]
returnseq
defbubbleSort(seq):
"""冒泡排序"""
size=len(seq)
foriinrange(1,size):
forjinrange(0,size-i):
ifseq[j+1]<seq[j]:
seq[j+1],seq[j]=seq[j],seq[j+1]
returnseq
def_divide(seq,low,high):
"""快速排序劃分函數"""
tmp=seq[low]
whilelow!=high:
whilelow<highandseq[high]>=tmp:high-=1
iflow<high:
seq[low]=seq[high]
low+=1
whilelow<highandseq[low]<=tmp:low+=1
iflow<high:
seq[high]=seq[low]
high-=1
seq[low]=tmp
returnlow
def_quickSort(seq,low,high):
"""快速排序輔助函數"""
iflow>=high:return
mid=_divide(seq,low,high)
_quickSort(seq,low,mid-1)
_quickSort(seq,mid+1,high)
defquickSort(seq):
"""快速排序包裹函數"""
size=len(seq)
_quickSort(seq,0,size-1)
returnseq
defmerge(seq,left,mid,right):
tmp=[]
i,j=left,mid
whilei<midandj<=right:
ifseq[i]<seq[j]:
tmp.append(seq[i])
i+=1
else:
tmp.append(seq[j])
j+=1
ifi<mid:tmp.extend(seq[i:])
ifj<=right:tmp.extend(seq[j:])
seq[left:right+1]=tmp[0:right-left+1]
def_mergeSort(seq,left,right):
ifleft==right:
return
else:
mid=(left+right)/2
_mergeSort(seq,left,mid)
_mergeSort(seq,mid+1,right)
merge(seq,left,mid+1,right)
#二路並歸排序
defmergeSort(seq):
size=len(seq)
_mergeSort(seq,0,size-1)
returnseq
if__name__=='__main__':
s=[random.randint(0,100)foriinrange(0,20)]
prints
print" "
printdirectSelectSort((s))
printdirectInsertSort((s))
printbubbleSort((s))
printquickSort((s))
printmergeSort((s))
❽ 求一個簡單的Python給數字排序代碼
簡單排序的話，直接使用 list.sort() 就可以了，直接在原列表上進行排序。
非要寫成函數的形式的話，代碼如下
defABC(nums_l):
nums_l.sort()
returnnums_l
l=[1,2,5,3,4]
#其實，使用l.sort()之後，就對l進行了排序，然後輸出l就可以了
printl
printABC(l)
這樣，輸出為
>>>================================RESTART================================
>>>
[1,2,5,3,4]
[1,2,3,4,5]
>>>
這么基礎的東西，不會的話，自己看書去。
defABC(nums_l):
returnsorted(nums_l)
defmain():
nums_l=[]
whileTrue:
try:
n=int(raw_input('inputnum:>').strip())
nums_l.append(n)
except:
break
print'',ABC(nums_l)
if__name__=='__main__':
main()
❾ 用python寫了一個快速排序演算法，總是報錯，求問哪裡出錯了
defquick_sort(lst,start_index,end_index):
ifstart_index>end_index:
return
tmp=lst[start_index]
i,j=start_index,end_index
whilei!=j:
while(lst[j]>=tmpandi<j):
j=j-1
while(lst[i]<=tmpandi<j):
i=i+1
ifi<j:
lst[i],lst[j]=lst[j],lst[i]
lst[start_index]=lst[i]
lst[i]=tmp
quick_sort(lst,start_index,i-1)
quick_sort(lst,i+1,end_index)
y=[33,12,45,32,6,78,109,2,1]
quick_sort(y,0,len(y)-1)
printy
❿ 求python中，自定義的復雜數據結構，快速排序的方法
應該是你sorted的使用方式不對吧，它可以對name.key這樣的形式進行排序的。
classm:
def__init__(self,name,id):
self.name=name
self.id=id
@property
defkey(self):
returnself.name
deflen(self):
returnlen(self.name)
def__str__(self):
return'{{'name':'{0}','id':{1}}}'
.format(self.name,self.id)
__repr__=__str__
s=[m('zzzz',1),m('aaa',4)]
l=[('source',s),
]
#直接屬性排序
l.append(('byname',sorted(s,key=lambdax:x.name)))
l.append(('byid',sorted(s,key=lambdax:x.id)))
#屬性函數排序
l.append(('bykey',sorted(s,key=lambdax:x.key)))
#函數排序
l.append(('bylen()',sorted(s,key=lambdax:x.len())))
foreinl:
print(e[0])
print(e[1])
這是輸出的結果：
source
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
byname
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
byid
[{'name':'zzzz','id':1},{'name':'aaa','id':4}]
bykey
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
bylen()
[{'name':'aaa','id':4},{'name':'zzzz','id':1}]
上述四種用法都是沒問題的，至於name[key]的形式同樣是OK的。
sorted的參數key，它是一個函數,簡單的話可以直接用lambda，復雜點的可以定義成有一個參數的函數，比如：
defsorted_other(item):
ifhasattr(item,'name'):
returnitem.name
else:
returnNone
l.append(('byotherfunc',sorted(s,key=sorted_other)))