1 排序
排序算法(英語:Sorting algorithm)是一種能將一串數據依照特定順序進行排列的一種算法。
1.1排序算法的穩定性
穩定性:穩定排序算法會讓原本有相等鍵值的紀錄維持相對次序。也就是如果一個排序算法是穩定的,當有兩個相等鍵值的紀錄R和S,且在原本的列表中R出現在S之前,在排序過的列表中R也將會是在S之前。
當相等的元素是無法分辨的,比如像是整數,穩定性並不是一個問題。然而,假設以下的數對將要以他們的第一個數字來排序。
(4, 1) (3, 1) (3, 7)(5, 6)
在這個狀況下,有可能產生兩種不同的結果,一個是讓相等鍵值的紀錄維持相對的次序,而另外一個則沒有:
(3, 1) (3, 7) (4, 1) (5, 6) (維持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改變)
不穩定排序算法可能會在相等的鍵值中改變紀錄的相對次序,但是穩定排序算法從來不會如此。不穩定排序算法可以被特別地實現爲穩定。作這件事情的一個方式是人工擴充鍵值的比較,如此在其他方面相同鍵值的兩個對象間之比較,(比如上面的比較中加入第二個標準:第二個鍵值的大小)就會被決定使用在原先數據次序中的條目,當作一個同分決賽。然而,要記住這種次序通常牽涉到額外的空間負擔。
1、冒泡排序
1.2 冒泡排序
學習目標:
- 記住 冒泡排序的原理
- 記住 冒泡排序的代碼實踐思路
- 應用 實踐思路寫出冒泡排序
冒泡排序(Bubble Sort)
它是一種簡單的排序算法。它重複地遍歷要排序的數列,一次比較兩個元素,如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重複地進行直到沒有再需要交換,也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。
冒泡排序算法的運作如下:
- 比較相鄰的元素。如果第一個比第二個大(升序),就交換他們兩個。
- 對每一對相鄰元素作同樣的工作,從開始第一對到結尾的最後一對。這步做完後,最後的元素會是最大的數。
- 針對所有的元素重複以上的步驟,除了最後一個。
- 持續每次對越來越少的元素重複上面的步驟,直到沒有任何一對數字需要比較。
代碼實現
def bubble_sort(alist):
for j in range(len(alist)-1,0,-1):
# j表示每次遍歷需要比較的次數,是逐漸減小的
for i in range(j):
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]
li = [54,26,93,17,77,31,44,55,20]
bubble_sort(li)
print(li)
時間複雜度
- 最優時間複雜度:O(n)
- 最壞時間複雜度:O(n2)
- 穩定性:穩定
小結
找最大
1.3 選擇排序
學習目標:
- 記住 選擇排序的原理
- 記住 選擇排序的代碼實踐思路
- 應用 實踐思路寫出選擇排序
選擇排序(Selection sort)
它是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然後,再從剩餘未排序元素中繼續尋找最小(大)元素,然後放到已排序序列的末尾。以此類推,直到所有元素均排序完畢。
選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上,則它不會被移動。選擇排序每次交換一對元素,它們當中至少有一個將被移到其最終位置上,因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中,選擇排序屬於非常好的一種。
代碼實現
def selection_sort(alist):
n = len(alist)
# 需要進行n-1次選擇操作
for i in range(n-1):
# 記錄最小位置
min_index = i
# 從i+1位置到末尾選擇出最小數據
for j in range(i+1, n):
if alist[j] < alist[min_index]:
min_index = j
# 如果選擇出的數據不在正確位置,進行交換
if min_index != i:
alist[i], alist[min_index] = alist[min_index], alist[i]
alist = [54,226,93,17,77,31,44,55,20]
selection_sort(alist)
print(alist)
時間複雜度
- 最優時間複雜度:O(n^2)
- 最壞時間複雜度:O(n^2)
- 穩定性:不穩定
小結
找最小
1.4 插入排序
學習目標:
- 記住 插入排序的原理
- 記住 插入排序的代碼實踐思路
- 應用 實踐思路寫出插入排序
插入排序(Insertion Sort)
是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列,對於未排序數據,在已排序序列中從後向前掃描,找到相應位置並插入。插入排序在實現上,在從後向前掃描過程中,需要反覆把已排序元素逐步向後挪位,爲最新元素提供插入空間。
代碼實現
ef insert_sort(alist):
# 從第二個位置,即下標爲1的元素開始向前插入
for i in range(1, len(alist)):
# 從第i個元素開始向前比較,如果小於前一個元素,交換位置
for j in range(i, 0, -1):
if alist[j] < alist[j-1]:
alist[j], alist[j-1] = alist[j-1], alist[j]
alist = [54,26,93,17,77,31,44,55,20]
insert_sort(alist)
print(alist)
時間複雜度
- 最優時間複雜度:O(n)
- 最壞時間複雜度:O(n2)
- 穩定性:穩定
小結
1、假設第1個元素有序,再右邊的無序裏 取最左邊和第1個比較,形成左邊有序組
2、右邊無序裏繼續取組左邊元素和,左邊有序組進行比較
。。。
1.5 希爾排序
學習目標:
- 記住 希爾排序的原理
- 記住 希爾排序的代碼實踐思路
- 應用 實踐思路寫出希爾排序
希爾排序(Shell Sort)
它是插入排序的一種。也稱縮小增量排序,是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因DL.Shell於1959年提出而得名。 希爾排序是把記錄按下標的一定增量分組,對每組使用直接插入排序算法排序;隨着增量逐漸減少,每組包含的關鍵詞越來越多,當增量減至1時,整個文件恰被分成一組,算法便終止。
代碼實現
def shell_sort(alist):
n = len(alist)
# 初始步長
gap = n / 2
while gap > 0:
# 按步長進行插入排序
for i in range(gap, n):
j = i
# 插入排序
while j>=gap and alist[j-gap] > alist[j]:
alist[j-gap], alist[j] = alist[j], alist[j-gap]
j -= gap
# 得到新的步長
gap = gap / 2
alist = [54,26,93,17,77,31,44,55,20]
shell_sort(alist)
print(alist)
時間複雜度
- 最優時間複雜度:根據步長序列的不同而不同
- 最壞時間複雜度:O(n2)
- 穩定性:不穩定
小結
定gap
1.6 快速排序
學習目標:
- 記住 快速排序的原理
- 記住 快速排序的代碼實踐思路
- 應用 實踐思路寫出快速排序
快速排序(Quicksort)
又稱劃分交換排序(partition-exchange sort),通過一趟排序將要排序的數據分割成獨立的兩部分,其中一部分的所有數據都比另外一部分的所有數據都要小,然後再按此方法對這兩部分數據分別進行快速排序,整個排序過程可以遞歸進行,以此達到整個數據變成有序序列。
排序步驟:
- 從數列中挑出一個元素,稱爲"基準"(pivot),
- 重新排序數列,所有元素比基準值小的擺放在基準前面,所有元素比基準值大的擺在基準的後面(相同的數可以到任一邊)。在這個分區結束之後,該基準就處於數列的中間位置。這個稱爲分區(partition)操作。
- 遞歸地(recursive)把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形,是數列的大小是零或一,也就是永遠都已經被排序好了。雖然一直遞歸下去,但是這個算法總會結束,因爲在每次的迭代(iteration)中,它至少會把一個元素擺到它最後的位置去。
代碼實現
def quick_sort(alist, start, end):
"""快速排序"""
# 遞歸的退出條件
if start >= end:
return
# 設定起始元素爲要尋找位置的基準元素
mid = alist[start]
# low爲序列左邊的由左向右移動的遊標
low = start
# high爲序列右邊的由右向左移動的遊標
high = end
while low < high:
# 如果low與high未重合,high指向的元素不比基準元素小,則high向左移動
while low < high and alist[high] >= mid:
high -= 1
# 將high指向的元素放到low的位置上
alist[low] = alist[high]
# 如果low與high未重合,low指向的元素比基準元素小,則low向右移動
while low < high and alist[low] < mid:
low += 1
# 將low指向的元素放到high的位置上
alist[high] = alist[low]
# 退出循環後,low與high重合,此時所指位置爲基準元素的正確位置
# 將基準元素放到該位置
alist[low] = mid
# 對基準元素左邊的子序列進行快速排序
quick_sort(alist, start, low-1)
# 對基準元素右邊的子序列進行快速排序
quick_sort(alist, low+1, end)
alist = [54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)
時間複雜度
最優時間複雜度:O(nlogn)
最壞時間複雜度:O(n2)
穩定性:不穩定
1.7 歸併排序
- 記住 歸併排序的原理
- 記住 歸併排序的代碼實踐思路
- 應用 實踐思路寫出歸併排序
歸併排序
它是採用分治法的一個非常典型的應用。歸併排序的思想就是先遞歸分解數組,再合併數組。
將數組分解最小之後,然後合併兩個有序數組,基本思路是比較兩個數組的最前面的數,誰小就先取誰,取了後相應的指針就往後移一位。然後再比較,直至一個數組爲空,最後把另一個數組的剩餘部分複製過來即可。
排序分析
代碼實現
def merge_sort(alist):
if len(alist) <= 1:
return alist
# 二分分解
num = len(alist)/2
left = merge_sort(alist[:num])
right = merge_sort(alist[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]:
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
result += left[l:]
result += right[r:]
return result
alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = mergeSort(alist)
print(sorted_alist)
時間複雜度
- 最優時間複雜度:O(nlogn)
- 最壞時間複雜度:O(nlogn)
result.append(left[l])
l += 1
else:
result.append(right[r])
r += 1
result += left[l:]
result += right[r:]
return result
alist = [54,26,93,17,77,31,44,55,20]
sorted_alist = mergeSort(alist)
print(sorted_alist)
### 時間複雜度
- 最優時間複雜度:O(nlogn)
- 最壞時間複雜度:O(nlogn)
- 穩定性:穩定