def bubble_sort(alist):
"""氣泡排序"""
n = len(alist)
for i in range(n-1): #外層迴圈次數
for j in range(n-1-i): #這裡 記得要 -i
if alist[j] > alist[j+1]:
alist[j], alist[j + 1] = alist[j+1], alist[j]
def bubble_sort_2(alist): #優化
"""氣泡排序"""
n = len(alist)
for i in range(n-1): #外層迴圈次數
count = 0
for j in range(n-1-i): #這裡 記得要 -i
if alist[j] > alist[j+1]:
alist[j], alist[j + 1] = alist[j+1], alist[j]
count += 1
if 0 == count:
return
''' 原理： 首先在未排序序列中找到最小(大)元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小(大)元素，然後放到已排序序列的末尾， 以此迴圈'''
def select_sort(alist):
"""選擇排序"""
n = len(alist)
for i in range(n - 1): # 外層迴圈次數
min_ind = i
for j in range(i+1,n):
if alist[min_ind] > alist[j]:
min_ind = j
#找到最小值索引，下面進行交換,這樣i每變化一次就確定乙個數的位置了
#alist[i], alist[min_ind] = alist[min_ind], alist[i] #推薦用下面的
if i != min_ind:
alist[i], alist[min_ind] = alist[min_ind], alist[i]
#理解其思想: i從1開始，i為無序序列 中的第乙個元素索引，i-1為有序序列 中的第最後乙個元素索引
def insert_sort(alist):
"""插入排序"""
n = len(alist)
#從第二個位置，即下標為i的元素開始向前插入
for i in range(1, n):
#從第i個元素開始向前比較，如果小於前乙個元素，交換位置
for j in range(i, 0, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j - 1] = alist[j - 1], alist[j]
# 如果不小於的化，就可以退出本次迴圈， 因為i-1為有序序列的最後乙個元素索引，所以前面都是有序的
else:
break
'''思想:快排是一種分而治之的策略,快排的工作過程其實比較簡單，三步走：:1) 選擇基準值 pivot 將陣列分成兩個子陣列：小於基準值的元素和大於基準值的元素。2) 對這兩個子陣列進行快速排序。3) 合併結果'''
def quick_sort_v1(alist):
if len(alist)<2: #遞迴結束條件
return alist
#用分治法解決
pivot = alist[0] #假設陣列的第乙個元素為pivot
less_pivot = [i for i in alist[1:] if i <=pivot]
more_pivot = [i for i in alist[1:] if i > pivot]
return quick_sort_v1(less_pivot) + [pivot] + quick_sort_v1(more_pivot)
#總結：
#第一是它需要額外的儲存空間，不是inplace 原地排序。
#第二是它的 partition 操作每次都要兩次遍歷整個陣列
def quick_sort(alist, start, end):
"""快速排序"""
if start >= end: # 遞迴結束條件
return
pivot = alist[start] # 假設基準值
low = start
high = end
while (low < high):
# 必須 high先左移
while (low < high) and alist[high] >= pivot:
high =high -1
alist[low] = alist[high] # 改變low的值
while (low < high) and alist[low] < pivot:
low =low + 1
alist[high] = alist[low] # 改變high的值
# 從迴圈退出時，low==high, 這樣就找到了pivot應該在的位置
alist[low] = pivot
# 對low左邊的列表執行快速排序
quick_sort(alist, start, low - 1)
# 對low右邊的列表排序
quick_sort(alist, low + 1, end)
'''歸併排序把陣列遞迴成只有單個元素的陣列，之後再不斷兩兩 合併，最後得到乙個有序陣列。1)分解：將待排序的 n 個元素分成各包含 n//2 個元素的子串行2)解決：使用歸併排序遞迴排序兩個子串行3)合併：合併兩個已經排序的子串行以產生已排序的答案'''
def merge(left_li,right_li):
res = #新的已排序好的列表
i, j =0, 0
#對2個列表中的元素 兩兩對比，將較小的追加到res中，並對當前列表下標加1
while( i
if left_li[i] <= right_li[j]:
i += 1
else:
j += 1
#退出迴圈後 至少有1個列表遍歷完了
res += left_li[i:] #a = [1,2,3] ---> a[3:] --->
res += right_li[j:]
return res
def merge_sort(alist):
"""歸併排序"""
n = len(alist)
if n < 2 :
return alist
mid = n // 2
# left 採用歸併排序後形成的有序的新的列表
left_li = merge_sort(alist[:mid])
# right 採用歸併排序後形成的有序的新的列表
right_li = merge_sort(alist[mid:])
#d對排序好的兩個列表合併，產生乙個新的排序好的列表
return merge(left_li, right_li)
python 實現常見排序演算法
coding utf 8 bubble sort 氣泡排序 時間複雜度最壞為o n2 最優的為n import time def bubble sort alist 氣泡排序 param alist return cur 1 while cur len alist 1 and len alist 1...
常見排序演算法Python實現
氣泡排序 最優時間複雜度 o n 最壞時間複雜度 o n 2 穩定性 穩定 def bubble sort alist 氣泡排序 for j in range len alist 1,0,1 count 0 for i in range j if alist i alist i 1 alist i ...
常見排序演算法 python實現
穩定性是指序列中相同的數字在排序後相對位置不發生改變 常見的且穩定的排序演算法有冒泡 歸併 插入，其餘的為非穩定的排序演算法 def bubble sort alist for j in range len alist 1 0,1 for i in range j if alist i alist ...