氣泡排序（英語：bubble sort）是一種簡單的排序演算法。它重複地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端。
## 思路
- 比較相鄰的元素。如果第乙個比第二個大（公升序），就交換他們兩個。
- 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
- 針對所有的元素重複以上的步驟，除了最後乙個。
- 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
## 實現
```python
def bubble_sort(lst):
# j表示每次遍歷需要比較的次數，是逐漸減小的
for j in range(len(lst)-1, 0, -1):
for i in range(j):
if lst[i] > lst[i+1]:
lst[i], lst[i+1] = lst[i+1], lst[i]
## 演示
!(## 時間複雜度
- 最優時間複雜度：o(n) （表示遍歷一次發現沒有任何可以交換的元素，排序結束。）
- 最壞時間複雜度：o(n2)
- 穩定性：穩定
# 選擇排序
## 簡介
選擇排序（selection sort）是一種簡單直觀的排序演算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
## 思路
選擇排序的主要優點與資料移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有乙個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。
## 實現
```python
def selection_sort(lst):
n = len(lst)
for i in range(n-1):
# 記錄最小位置
min_index = i
# 每迴圈一次，找到最小值的索引
for j in range(i+1, n):
# 如果比最小值小，就把j置為min_index
if lst[j] < lst[min_index]:
min_index = j
# 不相等時才交換
if min_index != i:
lst[i], lst[min_index] = lst[min_index], lst[i]
!(## 時間複雜度
- 最優時間複雜度：o(n2)
- 最壞時間複雜度：o(n2)
- 穩定性：不穩定（考慮公升序每次選擇最大的情況）
# 插入排序插入排序（英語：insertion sort）是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃瞄，找到相應位置並插入。插入排序在實現上，在從後向前掃瞄過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。
def insert_sort(lst):
for i in range(1, len(lst)):
# 從第i個元素開始向前比較，前面的已經是有序數列
for j in range(i, 0, -1):
# 逐個比較，直到待排序元素處於正確的位置上
if lst[j] < lst[j-1]:
lst[j], lst[j-1] = lst[j-1], lst[j]
!(# 快速排序
## 簡介
快速排序是一種常見的排序演算法，比選擇排序快得多。快速排序使用了分而治之和遞迴的思想
def quick_sort(lst):
if len(lst) < 2:
return lst # 基線條件，0，1個元素的列表不需要排序
else:
pivot = lst[0] # 基準元素
less = [i for i in lst if i < pivot] # 小於基準元素的元素組成的列表
greater = [i for i in lst if i > pivot] # 大於基準元素的元素組成的列表
return quick_sort(less) + [pivot] + quick_sort(greater)
## 時間複雜度
- 最優時間複雜度：o(nlogn)
- 最壞時間複雜度：o(n2)
- 穩定性：不穩定
補充：關於時間複雜度，遞迴呼叫o(logn)次，每次比較分割槽o(n)，合起來就是o(nlogn)
# 歸併排序
## 簡介
歸併排序是採用分治法的乙個非常典型的應用。歸併排序的思想就是先遞迴分解陣列，再合併陣列。
## 思路
- 將列表分成兩個列表
- 分別對列表進行歸併排序
- 比較兩個陣列的最前面的數，誰小先取誰
def merge_sort(lst):
if len(lst) <= 1:
return lst
# 二分分解
num = len(lst)//2
left = merge_sort(lst[:num])
right = merge_sort(lst[num:])
# 合併
return merge(left, right)
def merge(left, right):
"""將兩個有序陣列left和right合併成乙個大的陣列"""
# left 和 right的下標指標
l, r = 0, 0
result =
while l < len(left) and r < len(right):
if left[l] < right[r]:
l += 1
else:
r += 1
# 迴圈結束後，乙個陣列為空，另乙個陣列還有值，要把剩餘的新增到result裡
result += left[l:]
result += right[r:]
return result
!(## 時間複雜度
- 最優時間複雜度：o(nlogn)
- 最壞時間複雜度：o(nlogn)
- 穩定性：穩定
補充：關於時間複雜度，遞迴呼叫o(logn)次，每次比較o(n)，合起來就是o(nlogn)
## 常見演算法比較
!(
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 ...