def heap_sort(li):
def _heapfly(li):
start = (len(li)) // 2 - 1 # 獲取最後乙個葉子節點的父節點
for nod in range(start, -1, -1):
left = 2 * nod + 1
right = min(left + 1, len(li) - 1)
temp = left if li[left] > li[right] else right
if li[temp] > li[nod]:
li[temp], li[nod] = li[nod], li[temp]
return li
result =
for i in range(len(li)):
li = _heapfly(li)
return result
if __name__ == '__main__':
l = [3, 1, 4, 9, 6, 7, 5, 8, 2, 10, 14]
print(heap_sort(l))
def merge_sort(li):
def _merge(a, b):
result =
while a and b:
temp = a.pop(0) if a[0] < b[0] else b.pop(0)
result.extend(a if a else b)
return result
length = len(li)
if length == 1:
return li
else:
mid = int(length/2)
l = li[:mid]
r = li[mid:]
return _merge(merge_sort(l), merge_sort(r) )
if __name__ == '__main__':
print(merge_sort([1, 3, 5, 2, 7, 9, -1]))
def quicksort1(nums):
if len(nums) <= 1:
return nums
# 左子陣列
less =
# 右子陣列
greater =
# 基準數
base = nums.pop()
# 對原陣列進行劃分
for x in nums:
if x < base:
else:
# 遞迴呼叫
return quicksort1(less) + [base] + quicksort1(greater)
此方法是逐個和最後乙個比較，保留劃分點指標，遍歷一遍後交換。
另外， 相比遞迴， 維護乙個棧或者佇列， 不斷往裡放入需要排序的子串行（頭， 尾）， 直到棧/隊列為空.
def quite_sort(li):
left = 0
right = len(li)-1
stack = [(left, right)]
while stack:
print(f'棧資料->')
# print(f'棧資料->')
left, right = stack.pop()
# 這裡有三種思路, 埋坑，左右指標，前後指標
curr = _deal_with_1(li, left, right)
if curr > left+1:
if right > curr+1:
return li
# 前後指標
資料結構與演算法（九）排序
演算法 時間複雜度 平均 時間複雜度 最壞 時間複雜度 最好 空間複雜度 穩定性氣泡排序 o n 2 o n 2 o n o 1 穩定選擇排序 o n 2 o n 2 o n 2 o 1 不穩定插入排序 o n 2 o n 2 o n o 1 穩定希爾排序 o nlogn o n 2 o n o 1...
資料結構 2 排序演算法
常見的排序演算法 氣泡排序 選擇排序 插入排序 歸併排序 快速排序 堆排序 includeusing namespace std void swap int a,int i,int j 冒泡法 平均時間複雜度 o n 2 void bubblosort int a,int n void bubblo...
資料結構3 排序演算法
氣泡排序 演算法描述 排序問題是基本演算法，主要有冒泡演算法 插入排序以及選擇排序演算法。冒泡演算法是對整個列進行多次遍歷迴圈，直至將所有的數都比較一遍，每次迴圈都能產生乙個最大數放置於後面，這樣需要兩層迴圈 外層控制次數，內層控制單次冒泡，內層針對的是相鄰裡兩個進行比較的迴圈。using syst...