1. 快速排序：
class quicksort():
def __init__(self,nums):
self.nums = nums[:]
def partition(self,left,right):
key = self.nums[left]
while left=key: #注意這裡有個「=」，用來防止key被來回交換而陷入死迴圈。
right-=1
while left=right:
return
index = self.partition(left,right)
self.qs(left,index) #每次將陣列切成兩段，中間沒有空餘的位置。
self.qs(index+1,right)
if __name__ == '__main__':
nums = [10,22,1,9,87,3,2,66,1,8,9,0,7,7]
s = quicksort(nums)
s.qs(0,len(nums)-1)
print nums
print s.nums
2. 堆排序：
class heap:
def __init__(self,arr):
self.arr = arr
def insert(self,value): #insert from the end of arr
self.up()
def pop(self): #get the biggest one in array and resort the array
top = self.arr[0]
arr[0] = arr.pop()
self.down()
return top
def swap(self,child_index,parent_index):
arr[child_index],arr[parent_index] = arr[parent_index],arr[child_index]
def up(self):
child_index = len(arr)-1
while(true):
parent_index = (child_index-1)/2
if(parent_index>=0 and arr[child_index]>arr[parent_index]):
self.swap(child_index,parent_index)
child_index = parent_index
else:
break
def down(self):
parent = 0
end = len(arr)-1
while(true):
left_child = 2*parent+1
right_child = left_child+1
if(right_child<=end): #has two childern
if(arr[left_child]>arr[right_child]): #find the bigger child
bigger = left_child
else:
bigger = right_child
if(arr[parent]
def merge(left,right):
tmp =
while(left and right):
if(left[0]>right[0]): #將left or right 中,較大的元素彈入tmp;只能從前往後比較，因為每個子串行都是從小到大排列的。
else:
if(left): #將剩餘的元素彈入tmp
for i in left:
else:
for i in right:
return tmp
def merge_sort(arr):
if(len(arr)<=1):
return arr
mid = len(arr)/2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
res = merge(left,right)
return res
if __name__ == "__main__":
arr = [34,54,94,62,56,46,6,2]
print merge_sort(arr)
快速排序 堆排序 歸併排序
快速排序 includeusing namespace std int a 8 int sz sizeof a sizeof int int partition int a,int p,int r int main const int sz sizeof a sizeof int 堆化 保持最大堆的...
快速排序，歸併排序，堆排序
l r 1在奇數長度陣列的中間，偶數長度陣列的左半邊最後乙個，極限情況下陣列只有兩個數，i遇到第乙個數就會停下，此時模擬i，j下標的數有無交換的情況，會發現j在停下來時都位於第乙個數的位置，因此用j，j 1才不會越界 l r 1 1在奇數長度陣列的中間往右第乙個，偶數長度陣列的右半邊第乙個，極限情況...
關於快速排序，歸併排序，堆排序
1 快速排序 quicksort 快速排序是乙個就地排序，分而治之，大規模遞迴的演算法。從本質上來說，它是歸併排序的就地版本。快速排序可以由下面四步組成。1 如果不多於1個資料，直接返回。2 一般選擇序列最左邊的值作為支點資料。3 將序列分成2部分，一部分都大於支點資料，另外一部分都小於支點資料。4...