python快速排序

A. python演算法有哪些

Python演算法的特徵

1. 有窮性：演算法的有窮性指演算法必須能在執行有限個步驟之後終止;

2. 確切性：演算法的每一步驟必須有確切的定義;

3. 輸入項：一個演算法有0個或多個輸入，以刻畫運算對象的初始情況，所謂0個輸入是指演算法本身定出了初始條件;

4. 輸出項：一個演算法有一個或多個輸出，以反映對輸入數據加工後的結果，沒有輸出的演算法是毫無意義的;

5. 可行性：演算法中執行的任何計算步驟都是可以被分解為基本的可執行操作步，即每個計算步都可以在有限時間內完成;

6. 高效性：執行速度快、佔用資源少;

7. 健壯性：數據響應正確。

Python演算法分類：

1.
冒泡排序：是一種簡單直觀的排序演算法。重復地走訪過要排序的數列，一次比較兩個元素，如果順序錯誤就交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該排序已經完成。

2.
插入排序：沒有冒泡排序和選擇排序那麼粗暴，其原理最容易理解，插入排序是一種最簡單直觀的排序演算法啊，它的工作原理是通過構建有序序列，對於未排序數據在已排序序列中從後向前排序，找到對應位置。

3.
希爾排序：也被叫做遞減增量排序方法，是插入排序的改進版本。希爾排序是基於插入排序提出改進方法的排序演算法，先將整個待排序的記錄排序分割成為若干個子序列分別進行直接插入排序，待整個序列中的記錄基本有序時，再對全記錄進行依次直接插入排序。

4. 歸並排序：是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法Divide and的一個非常典型的應用。

5. 快速排序：由東尼·霍爾所發展的一種排序演算法。又是一種分而治之思想在排序演算法上的典型應用，本質上快速排序應該算是冒泡排序基礎上的遞歸分治法。

6.
堆排序：是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質，即子結點的鍵值或索引總是小於它的父結點。

7.
計算排序：其核心在於將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中，作為一種線性時間復雜度的排序，計算排序要求輸入的數據必須是具有確定范圍的整數。

B. 求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)))

C. Python中既然有了sort()可以排序，那還有必要實現其他排序演算法嗎例如堆排序，快速排序

肯定有必要的，sort是基於快速排序，但我們編程的時候不單單要會用，而且要知道原理
此外，有些情況下冒泡、選擇排序的時間復雜度也不差，而且實現簡單，更適用於一些小數據量的情況，這時候這些排序反而有優勢
而且有時候數據結構不一定是整型等， 是我們自定義的類型，要對其中的某個成員變數排序，知道原理就更容易理解

D. python中列表如何快速

//快速排序（分治法）
defquicksort(arr):
iflen(arr)<2:
//快速排序數組元素為0或1時，則直接輸出
returnarr
else:
//取第一個值為中心數
pivot=arr[0]
//取剩餘值
arr=arr[1:]
//將小於中心數的數放在less數組
less=[iforiinarrifi<=pivot]
//將大於中心數的數放在more數組
greater=[iforiinarrifi>pivot]
//遞歸
//分解成quicksort(less)，quicksort(greater)這兩個更小的部分（分治法）
returnquicksort(less)+[pivot]+quicksort(greater)

E. 求助幫忙看一下用python實現快速排序的代碼為什麼一直無限循環了應該怎麼修改呢

非常簡單，就把第一個if left > right 改成 left >= right就可以了。。
當left = right的時候也應該是退出的條件，你沒有加上所以就陷入了while != j這個循環裡面了。。
在這個裡面 left = right =j,而i=left+1=j+1，所以i>j,而你的判斷條件只有i<j的，所以兩個while和一個if都不滿足就一直死循環了。。

F. 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))

G. python包含什麼演算法

Python基礎演算法有哪些?
1.
冒泡排序：是一種簡單直觀的排序演算法。重復地走訪過要排序的數列，一次比較兩個元素，如果順序錯誤就交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該排序已經完成。
2.
插入排序：沒有冒泡排序和選擇排序那麼粗暴，其原理最容易理解，插入排序是一種最簡單直觀的排序演算法啊，它的工作原理是通過構建有序序列，對於未排序數據在已排序序列中從後向前排序，找到對應位置。
3.
希爾排序：也被叫做遞減增量排序方法，是插入排序的改進版本。希爾排序是基於插入排序提出改進方法的排序演算法，先將整個待排序的記錄排序分割成為若干個子序列分別進行直接插入排序，待整個序列中的記錄基本有序時，再對全記錄進行依次直接插入排序。
4. 歸並排序：是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法Divide and的一個非常典型的應用。
5. 快速排序：由東尼·霍爾所發展的一種排序演算法。又是一種分而治之思想在排序演算法上的典型應用，本質上快速排序應該算是冒泡排序基礎上的遞歸分治法。
6.
堆排序：是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質，即子結點的鍵值或索引總是小於它的父結點。
7.
計算排序：其核心在於將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中，作為一種線性時間復雜度的排序，計算排序要求輸入的數據必須是具有確定范圍的整數。

H. 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]

I. python 快速排序實現的具體代碼，以及講解。我是小白還請講清楚一點，謝謝了。

快速排序：在數組L中選一個數叫支點Pivot，把數組L中所有比支點小的數放在支點的左邊；比支點大的數放在支點右邊..；然後分別對左、右兩個新數組重新各選一個支點，重復之前的排法，直到左、右只剩下一個數不用再分。經過這樣的過程後，整個數組L就被從小到大排好了.
qsort()是排序的實現。qsort(數組，起點序號，終點序號)；內容是由partition分好一輪後再分別排左、右子數組。
partition()是選支點，並分配數給左右和區分左右的過程。

J. python 演算法有哪些比賽

演算法是指解題方案的准確而完整的描述，是一系列解決問題的清晰指令，演算法代表著用系統的方法描述解決問題的策略機制。簡單來講，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。包括這幾類：
1.
選擇排序演算法：選擇排序是一種簡單直觀的排序演算法。原理：首先在未排序序列中找到最小或最大元素，存放到排序序列的起始位置;然後，再從剩餘未排序元素中繼續尋找最大最小元素，然後放到已排序序列的後面，以此類推直到所有元素均排序完畢。
2.
快速排序演算法：快速排序的運行速度快於選擇排序。原理：設要排序的數組為N，首先任意選取一個數據作為關鍵數據，然後將所有比它小的數放到它前面，所有比它大的數都放到它後面，這個過程稱之為快速排序。
3. 二分查找演算法：二分查找的輸入是一個有序的列表，如果要查找的元素包含在一個有序列表中，二分查找可以返回其位置。
4.
廣度優先搜索演算法：屬於一種圖演算法，圖由節點和邊組成。一個節點可以與多個節點連接，這些節點稱為鄰居。它可以解決兩類問題：第一類是從節點A出發，在沒有前往節點B的路徑;第二類問題是從節點A出發，前往B節點的哪條路徑最短。使用廣度優先搜索演算法的前提是圖的邊沒有權值，即該演算法只用於非加權圖中，如果圖的邊有權值的話就應該使用狄克斯特拉演算法來查找最短路徑。
5.
貪婪演算法：又叫做貪心演算法，對於沒有快速演算法的問題，就只能選擇近似演算法，貪婪演算法尋找局部最優解，並企圖以這種方式獲得全局最優解，它易於實現、運行速度快，是一種不錯的近似演算法。