文章來源：數(shù)據(jù)結(jié)構(gòu)與算法（Python）
排序與搜索
排序算法（英語：Sorting algorithm）是一種能將一串?dāng)?shù)據(jù)依照特定順序進行排列的一種算法各薇。
1.冒泡排序
冒泡排序（英語：Bubble Sort）是一種簡單的排序算法。它重復(fù)地遍歷要排序的數(shù)列疙筹，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來庶溶。遍歷數(shù)列的工作是重復(fù)地進行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個算法的名字由來是因為越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端枪眉。
冒泡排序算法的運作如下：
- 比較相鄰的元素。如果第一個比第二個大（升序）再层，就交換他們兩個贸铜。
- 對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對聂受。這步做完后蒿秦，最后的元素會是最大的數(shù)。
- 針對所有的元素重復(fù)以上的步驟蛋济，除了最后一個棍鳖。
- 持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較瘫俊。
冒泡排序的分析
交換過程圖示(第一次)：
那么我們需要進行n-1次冒泡過程，每次對應(yīng)的比較次數(shù)如下圖所示：
def bubble_sort(alist):
for j in range(len(alist)-1,0,-1):
# j表示每次遍歷需要比較的次數(shù)悴灵，是逐漸減小的
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)
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(n) （表示遍歷一次發(fā)現(xiàn)沒有任何可以交換的元素扛芽，排序結(jié)束。）
- 最壞時間復(fù)雜度：O(n2)
- 穩(wěn)定性：穩(wěn)定
冒泡排序的演示
效果：
2.選擇排序
選擇排序（Selection sort）是一種簡單直觀的排序算法积瞒。它的工作原理如下川尖。首先在未排序序列中找到最小（大）元素茫孔，存放到排序序列的起始位置叮喳，然后，再從剩余未排序元素中繼續(xù)尋找最戌直础（大）元素馍悟，然后放到已排序序列的末尾。以此類推剩晴，直到所有元素均排序完畢锣咒。
選擇排序的主要優(yōu)點與數(shù)據(jù)移動有關(guān)。如果某個元素位于正確的最終位置上赞弥，則它不會被移動毅整。選擇排序每次交換一對元素，它們當(dāng)中至少有一個將被移到其最終位置上绽左，因此對n個元素的表進行排序總共進行至多n-1次交換悼嫉。在所有的完全依靠交換去移動元素的排序方法中，選擇排序?qū)儆诜浅：玫囊环N拼窥。
選擇排序分析
排序過程：
def selection_sort(alist):
n = len(alist)
# 需要進行n-1次選擇操作
for i in range(n-1):
# 記錄最小位置
min_index = i
# 從i+1位置到末尾選擇出最小數(shù)據(jù)
for j in range(i+1, n):
if alist[j] < alist[min_index]:
min_index = j
# 如果選擇出的數(shù)據(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)
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(n2)
- 最壞時間復(fù)雜度：O(n2)
- 穩(wěn)定性：不穩(wěn)定（考慮升序每次選擇最大的情況）
選擇排序演示
3.插入排序
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法仙粱。它的工作原理是通過構(gòu)建有序序列，對于未排序數(shù)據(jù)彻舰，在已排序序列中從后向前掃描伐割，找到相應(yīng)位置并插入。插入排序在實現(xiàn)上刃唤，在從后向前掃描過程中隔心，需要反復(fù)把已排序元素逐步向后挪位，為最新元素提供插入空間尚胞。
插入排序分析
def insert_sort(alist):
# 從第二個位置硬霍，即下標(biāo)為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)
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(n) （升序排列唯卖，序列已經(jīng)處于升序狀態(tài)）
- 最壞時間復(fù)雜度：O(n2)
- 穩(wěn)定性：穩(wěn)定
插入排序演示
4.快速排序
快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort）躬柬，通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨立的兩部分拜轨，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分?jǐn)?shù)據(jù)分別進行快速排序允青，整個排序過程可以遞歸進行橄碾，以此達(dá)到整個數(shù)據(jù)變成有序序列。
步驟為：
1.從數(shù)列中挑出一個元素颠锉，稱為"基準(zhǔn)"（pivot）法牲，
2.重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面琼掠，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）拒垃。在這個分區(qū)結(jié)束之后，該基準(zhǔn)就處于數(shù)列的中間位置瓷蛙。這個稱為分區(qū)（partition）操作恶复。
遞歸地（recursive）把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序。
3.遞歸的最底部情形速挑，是數(shù)列的大小是零或一谤牡，也就是永遠(yuǎn)都已經(jīng)被排序好了。雖然一直遞歸下去姥宝，但是這個算法總會結(jié)束翅萤，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
快速排序的分析
def quick_sort(alist, start, end):
"""快速排序"""
# 遞歸的退出條件
if start >= end:
return
# 設(shè)定起始元素為要尋找位置的基準(zhǔn)元素
mid = alist[start]
# low為序列左邊的由左向右移動的游標(biāo)
low = start
# high為序列右邊的由右向左移動的游標(biāo)
high = end
while low < high:
# 如果low與high未重合套么，high指向的元素不比基準(zhǔn)元素小培己，則high向左移動
while low < high and alist[high] >= mid:
high -= 1
# 將high指向的元素放到low的位置上
alist[low] = alist[high]
# 如果low與high未重合，low指向的元素比基準(zhǔn)元素小胚泌，則low向右移動
while low < high and alist[low] < mid:
low += 1
# 將low指向的元素放到high的位置上
alist[high] = alist[low]
# 退出循環(huán)后省咨，low與high重合，此時所指位置為基準(zhǔn)元素的正確位置
# 將基準(zhǔn)元素放到該位置
alist[low] = mid
# 對基準(zhǔn)元素左邊的子序列進行快速排序
quick_sort(alist, start, low-1)
# 對基準(zhǔn)元素右邊的子序列進行快速排序
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)
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(nlogn)
- 最壞時間復(fù)雜度：O(n2)
- 穩(wěn)定性：不穩(wěn)定
從一開始快速排序平均需要花費O(n log n)時間的描述并不明顯玷室。但是不難觀察到的是分區(qū)運算零蓉，數(shù)組的元素都會在每次循環(huán)中走訪過一次，使用O(n)的時間穷缤。在使用結(jié)合（concatenation）的版本中敌蜂，這項運算也是O(n)。
在最好的情況津肛，每次我們運行一次分區(qū)章喉，我們會把一個數(shù)列分為兩個幾近相等的片段。這個意思就是每次遞歸調(diào)用處理一半大小的數(shù)列身坐。因此秸脱，在到達(dá)大小為一的數(shù)列前，我們只要作log n次嵌套的調(diào)用部蛇。這個意思就是調(diào)用樹的深度是O(log n)摊唇。但是在同一層次結(jié)構(gòu)的兩個程序調(diào)用中，不會處理到原來數(shù)列的相同部分搪花；因此遏片，程序調(diào)用的每一層次結(jié)構(gòu)總共全部僅需要O(n)的時間（每個調(diào)用有某些共同的額外耗費嘹害，但是因為在每一層次結(jié)構(gòu)僅僅只有O(n)個調(diào)用撮竿，這些被歸納在O(n)系數(shù)中）。結(jié)果是這個算法僅需使用O(n log n)時間笔呀。
快速排序演示
5.希爾排序
希爾排序(Shell Sort)是插入排序的一種幢踏。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本许师。希爾排序是非穩(wěn)定排序算法房蝉。該方法因DL．Shell于1959年提出而得名。 希爾排序是把記錄按下標(biāo)的一定增量分組微渠，對每組使用直接插入排序算法排序搭幻；隨著增量逐漸減少，每組包含的關(guān)鍵詞越來越多逞盆，當(dāng)增量減至1時檀蹋，整個文件恰被分成一組，算法便終止云芦。
希爾排序過程
希爾排序的基本思想是：將數(shù)組列在一個表中并對列分別進行插入排序俯逾，重復(fù)這過程贸桶，不過每次用更長的列（步長更長了，列數(shù)更少了）來進行桌肴。最后整個表就只有一列了皇筛。將數(shù)組轉(zhuǎn)換至表是為了更好地理解這算法，算法本身還是使用數(shù)組進行排序坠七。
例如水醋，假設(shè)有這樣一組數(shù)[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序灼捂，我們可以通過將這列表放在有5列的表中來更好地描述算法离例，這樣他們就應(yīng)該看起來是這樣(豎著的元素是步長組成)：
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
然后我們對每列進行排序：
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
將上述四行數(shù)字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]悉稠。這時10已經(jīng)移至正確位置了宫蛆，然后再以3為步長進行排序：
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
排序之后變?yōu)椋?/p>
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
最后以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)
時間復(fù)雜度
最優(yōu)時間復(fù)雜度：根據(jù)步長序列的不同而不同
最壞時間復(fù)雜度：O(n2)
穩(wěn)定想：不穩(wěn)定
希爾排序演示
6.歸并排序
歸并排序是采用分治法的一個非常典型的應(yīng)用。歸并排序的思想就是先遞歸分解數(shù)組的猛，再合并數(shù)組耀盗。
將數(shù)組分解最小之后，然后合并兩個有序數(shù)組卦尊，基本思路是比較兩個數(shù)組的最前面的數(shù)叛拷，誰小就先取誰，取了后相應(yīng)的指針就往后移一位岂却。然后再比較忿薇，直至一個數(shù)組為空，最后把另一個數(shù)組的剩余部分復(fù)制過來即可躏哩。
歸并排序的分析
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):
'''合并操作署浩，將兩個有序數(shù)組left[]和right[]合并成一個大的有序數(shù)組'''
#left與right的下標(biāo)指針
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)
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(nlogn)
- 最壞時間復(fù)雜度：O(nlogn)
- 穩(wěn)定性：穩(wěn)定
7.常見排序算法效率比較
8.搜索
搜索是在一個項目集合中找到一個特定項目的算法過程。搜索通常的答案是真的或假的扫尺，因為該項目是否存在筋栋。 搜索的幾種常見方法：順序查找、二分法查找正驻、二叉樹查找弊攘、哈希查找
二分法查找
二分查找又稱折半查找，優(yōu)點是比較次數(shù)少姑曙，查找速度快襟交，平均性能好；其缺點是要求待查表為有序表伤靠，且插入刪除困難捣域。因此，折半查找方法適用于不經(jīng)常變動而查找頻繁的有序列表。首先竟宋，假設(shè)表中元素是按升序排列提完，將表中間位置記錄的關(guān)鍵字與查找關(guān)鍵字比較，如果兩者相等丘侠，則查找成功徒欣；否則利用中間位置記錄將表分成前、后兩個子表蜗字，如果中間位置記錄的關(guān)鍵字大于查找關(guān)鍵字打肝，則進一步查找前一子表，否則進一步查找后一子表挪捕。重復(fù)以上過程粗梭，直到找到滿足條件的記錄，使查找成功级零，或直到子表不存在為止断医，此時查找不成功。
二分法查找實現(xiàn)
（非遞歸實現(xiàn)）
def binary_search(alist, item):
first = 0
last = len(alist)-1
while first<=last:
midpoint = (first + last)/2
if alist[midpoint] == item:
return True
elif item < alist[midpoint]:
last = midpoint-1
else:
first = midpoint+1
return False
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))
（遞歸實現(xiàn)）
def binary_search(alist, item):
if len(alist) == 0:
return False
else:
midpoint = len(alist)//2
if alist[midpoint]==item:
return True
else:
if item<alist[midpoint]:
return binary_search(alist[:midpoint],item)
else:
return binary_search(alist[midpoint+1:],item)
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))
時間復(fù)雜度
- 最優(yōu)時間復(fù)雜度：O(1)
- 最壞時間復(fù)雜度：O(logn)
