文章目錄

• • 前言
  • 1、冒泡排序
  • 2、選擇排序
  • 3、插入排序
  • 4、希爾排序
  • 5、快速排序
  • 6、歸并排序
  • 7、二分法查找
  • 總結(jié)

前言

最近復(fù)習(xí)了下常見的算法，在這里手動再寫一遍，權(quán)當(dāng)加深自己的印象。代碼實現(xiàn)用的是python3.6版本。

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ù)如下圖所示：

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：O(n) （表示遍歷一次發(fā)現(xiàn)沒有任何可以交換的元素，排序結(jié)束。）
最壞時間復(fù)雜度：O(n2)
穩(wěn)定性：穩(wěn)定
總結(jié)：冒泡實質(zhì)就是將列表中的數(shù)據(jù)依次兩兩比較，將較大值往列表的后排放，就像冒泡一樣，直到所有的列表的前兩個數(shù)據(jù)的大小也被確定。
代碼實現(xiàn)：

#版本一：一般實現(xiàn) def bubble_sort(alist): #再寫外層循環(huán)，需要執(zhí)行n-1次n=len(alist)for j in range(0,n-1):#先寫內(nèi)層循環(huán)，兩個數(shù)據(jù)兩兩比較大小，大的值往右移。for i in range(1,n-j)if alist[i]<alist[i-1]:alist[i],alist[i-1]=alist[i-1],alist[i]版本二：優(yōu)化版本。 #這里通過設(shè)置參數(shù)來判斷之前的子列表數(shù)據(jù)是否有序，若有序則無需再進行重復(fù)的排序計算。 def bubble_sort(alist):n = len(alist) #要進行n-1次比較排序for j in range(n-1): # [1, 2,3 ,4 ,6,5]則5和6順序換過之后，就不用再兩兩比較排序了count = 0for i in range(0, n-1-j):# 班長從頭走到尾，換一下位置count加1；if alist[i] > alist[i+1]:alist[i],alist[i+1] = alist[i+1], alist[i]count += 1 #count用于判斷序列是否有序，若本身有序的話即count==0則說明之前的數(shù)據(jù)有序則無需再進行重復(fù)的排序計算直接結(jié)束程序if 0 == count:return# i 0 ~ n-2 range(0, n-1) j=0 # i 0 ~ n-3 range(0, n-1-1) j=1 # i 0 ~ n-4 range(0, n-1-2) j=2 # j=n i range(0, n-1-j) if __name__ == "__main__":li = [54, 26, 93, 17, 77, 31, 44, 55, 20]print(li)bubble_sort(li)print(li)

2、選擇排序

原理：
選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
選擇排序的主要優(yōu)點與數(shù)據(jù)移動有關(guān)。如果某個元素位于正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當(dāng)中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序?qū)儆诜浅：玫囊环N。
選擇排序分析
排序過程：

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：O(n2)
最壞時間復(fù)雜度：O(n2)
穩(wěn)定性：不穩(wěn)定（考慮升序每次選擇最大的情況）

總結(jié)：首先需要一個min坐標(biāo)標(biāo)記最小值，之后對右邊的無序序列進行遍歷選擇操作，若找到比min值還小的數(shù)就交換位置<與冒泡的區(qū)別：冒泡兩兩比較將大的值往后移，選擇是設(shè)定一個min的索引然后拿選定的最小值和右邊的無序序列分別進行遍歷比較，最終得到最小值與min索引指向的值進行交換。>
代碼實現(xiàn)：

**版本一：一般實現(xiàn)**def select_sort(alist):n=len(alist)#外層循環(huán)控制執(zhí)行多少次下面的操作for j in range(n-1):min = j#先寫內(nèi)層循環(huán)用于拿指定的“最小”值（遍歷右邊的無序序列）和右邊的無序序列分別進行兩兩比較，并將比“最小”值小的值和“最小”值互換位置。for i in range(j+1, n):#min為最小值得索引指標(biāo)if alist[min] > alist[i]:alist[min], alist[i] = alist[i], alist[min]版本二：優(yōu)化版本。（只是記錄最小索引的位置信息等到一輪循環(huán)結(jié)束后再確定最終的最小值進行賦值操作）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]:#只是記錄最小索引的位置信息等到該循環(huán)結(jié)束后再確定最終的最小值min_index = jalist[i], alist[min_index] = alist[min_index], alist[i]alist = [54,226,93,17,77,31,44,55,20] selection_sort(alist) print(alist)

3、插入排序

原理：
插入排序（英語：Insertion Sort）是一種簡單直觀的排序算法。它的工作原理是通過構(gòu)建有序序列，對于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應(yīng)位置并插入。插入排序在實現(xiàn)上，在從后向前掃描過程中，需要反復(fù)把已排序元素逐步向后挪位，為最新元素提供插入空間。
插入排序分析

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：O(n) （升序排列，序列已經(jīng)處于升序狀態(tài)）
最壞時間復(fù)雜度：O(n2)
穩(wěn)定性：穩(wěn)定

總結(jié)：從右邊的無序序列中拿數(shù)據(jù)插入到左邊的有序序列中。
代碼實現(xiàn)：

**版本一：一般實現(xiàn)**def insert_sort(alist):#再寫外層循環(huán),需要確定n-1個元素后整個隊列才有序。for j in range(n-1)i=j#先寫內(nèi)層循環(huán)用于拿右邊無序序列中的一個元素和左邊的有序序列中的元素兩兩比較，插入到合適的位置。while i>=0:if alist[i]>alist[i+1]:alist[i],alist[i+1]=alist[i+1],alist[i]i-=1版本二：優(yōu)化版本。（當(dāng)右邊取得值比左邊的最大值大時，直接插入左邊然后break。不必進行重復(fù)的操做。）def insert_sort(alist):# 從第二個位置，即下標(biāo)為1的元素開始向前插入 #從右邊的無序列表中取出多少個元素執(zhí)行以下的過程n=len(alist)for j in range(1, n):# 從第i個元素開始向前比較，如果小于前一個元素，交換位置i=j #從右邊的無序序列中取出第一個元素，即i位置的元素，然后和左邊的有序序列中的元素進行比較插入合適的位置。while i>0： if alist[i] < alist[i-1]:alist[i], alist[i-1] = alist[i-1], alist[i] #優(yōu)化的過程：當(dāng)右邊取得值比左邊的最大值大時，直接插入左邊然后break。不必進行重復(fù)的操做。else:breakalist = [54,26,93,17,77,31,44,55,20] insert_sort(alist) print(alist)

4、希爾排序

原理：
希爾排序(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)?#xff1a;
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以1步長進行排序（此時就是簡單的插入排序了）
希爾排序的分析

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：根據(jù)步長序列的不同而不同
最壞時間復(fù)雜度：O(n2)
穩(wěn)定想：不穩(wěn)定

總結(jié)：將一數(shù)列看成多組無序數(shù)列然后對每組數(shù)列進行插入排序，之后再縮短步長重新進行分組排序。這個算法的確挺麻煩，但和插入算法結(jié)合起來會容易記點
代碼實現(xiàn)：

**版本一：一般實現(xiàn)**def shell_sort(alist):n=len(alist)grap = n // 2while grap > 0:#grap，grap+1...for j in range(grap, n):i = j#對每組中的各個元素分別進行比較初步排序while i > 0:if alist[i] < alist[i - grap]:alist[i], alist[i - grap] = alist[i - grap], alist[i]i -= grap#縮短步長再次進行分組比較，每組中各個元素進行兩兩比較。grap = grap // 2版本二：優(yōu)化版本。（同插入算法一樣增加了break，避免對已排序的序列再次進行排序操作）def shell_sort(alist):"""希爾排序"""# n=9n = len(alist)# gap =4gap = n // 2# i = gap# for i in range(gap, n):# # i = [gap, gap+1, gap+2, gap+3... n-1]# while:# if alist[i] < alist[i-gap]:# alist[i], alist[i-gap] = alist[i-gap], alist[i]# gap變化到0之前，插入算法執(zhí)行的次數(shù)while gap > 0:# shell算法，與普通的插入算法的區(qū)別就是gap步長for j in range(gap, n):# j = [gap, gap+1, gap+2, gap+3, ..., n-1]拿多少個元素進行操作i = j # i 可以認為無序序列中要插入有序序列中元素的下標(biāo)while i > 0:if alist[i] < alist[i-gap]:alist[i], alist[i-gap] = alist[i-gap], alist[i]i -= gapelse:break# 縮短gap步長gap //= 2if __name__ == "__main__":li = [54, 26, 93, 17, 77, 31, 44, 55, 20]print(li)shell_sort(li)print(li)

5、快速排序

原理：
快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分數(shù)據(jù)分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數(shù)據(jù)變成有序序列。
步驟為：
從數(shù)列中挑出一個元素，稱為"基準"（pivot），
重新排序數(shù)列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數(shù)可以到任一邊）。在這個分區(qū)結(jié)束之后，該基準就處于數(shù)列的中間位置。這個稱為分區(qū)（partition）操作。
遞歸地（recursive）把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序。
遞歸的最底部情形，是數(shù)列的大小是零或一，也就是永遠都已經(jīng)被排序好了。雖然一直遞歸下去，但是這個算法總會結(jié)束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。
快速排序的分析

時間復(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ù)列。因此，在到達大小為一的數(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)時間。

總結(jié)：最主要是采用遞歸的思想去解決問題
代碼實現(xiàn)：

**版本一：一般實現(xiàn)**def quick_sort(alist,start,end):if start>end:return#先寫內(nèi)層循環(huán)mind=alist[start]low=starthigh=endwhile low<high:if low<high and mind>alist[high]:alist[high],alist[low]=alist[low],alist[high]low+=1if low<high and mind<alist[low]:alist[high],alist[low]=alist[low],alist[high]high-=1alist[low]=mindquick_sort(alist,start,low-1)quick_sort(alist,low+1,end)if __name__ == "__main__":li = [54, 26, 93, 17, 77, 31, 44, 55, 20]print(li)shell_sort(li)print(li)**版本二：詳細解釋** def quick_sort(alist, start, end):"""快速排序"""# 注意這個條件：遞歸的退出條件即每個列表的元素為1if start >= end:return# 設(shè)定起始元素為要尋找位置的基準元素mid = alist[start]# low為序列左邊的由左向右移動的游標(biāo)low = start# high為序列右邊的由右向左移動的游標(biāo)high = endwhile 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]# 退出循環(huán)后，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)版本三： def qsort(L):if len(L) <= 1: return Lreturn qsort([lt for lt in L[1:] if lt < L[0]]) + L[0:1]+ \qsort([ge for ge in L[1:] if ge >= L[0]]) L = [3,14,2,12,9,33,99,35] print (qsort(L))

6、歸并排序

原理：
歸并排序是采用分治法的一個非常典型的應(yīng)用。歸并排序的思想就是先遞歸分解數(shù)組，再合并數(shù)組。
將數(shù)組分解最小之后，然后合并兩個有序數(shù)組，基本思路是比較兩個數(shù)組的最前面的數(shù)，誰小就先取誰，取了后相應(yīng)的指針就往后移一位。然后再比較，直至一個數(shù)組為空，最后把另一個數(shù)組的剩余部分復(fù)制過來即可。
歸并排序的分析：
先拆分后排序結(jié)合

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：O(nlogn)
最壞時間復(fù)雜度：O(nlogn)
穩(wěn)定性：穩(wěn)定

總結(jié)：先將數(shù)列拆分成多個數(shù)列每個數(shù)列只有一個元素，然后將各個數(shù)列再兩兩結(jié)合成新的數(shù)列，結(jié)合的過程中進行排序（如A和B兩個數(shù)列的第一個元素比較大小，小的插入到新的列表中的第一個元素的位置，大的緊隨其后，然后再對兩列的第二個元素進行上述操作）直到最終合成為一個序列然后再依次進行排序。
代碼實現(xiàn)：

def merge_sort(alist):"""歸并排序"""n = len(alist)if n <= 1:return alistmid = n//2# left 采用歸并排序后形成的有序的新的列表left_li = merge_sort(alist[:mid])# right 采用歸并排序后形成的有序的新的列表right_li = merge_sort(alist[mid:])# 將兩個有序的子序列合并為一個新的整體# merge(left, right)left_pointer, right_pointer = 0, 0result = [] #核心代碼：拿左右兩個隊列中的每個元素分別進行比較，依次將最小值加入新的隊列中while left_pointer < len(left_li) and right_pointer < len(right_li):if left_li[left_pointer] <= right_li[right_pointer]:result.append(left_li[left_pointer])left_pointer += 1else:result.append(right_li[right_pointer])right_pointer += 1 result += left_li[left_pointer:]result += right_li[right_pointer:]return resultif __name__ == "__main__":li = [54, 26, 93, 17, 77, 31, 44, 55, 20]print(li)sorted_li = merge_sort(li)print(li)print(sorted_li) #運行過程分析# merge_sort [54, 26, 93, 17, 77, 31, 44, 55, 20]## left_li = merge_sort [54, 26, 93, 17]## left_li = merge_sort [54, 26]# left_li = [26, 54]# left_li = merge_sort [54] return [54]# left_li = merge_sort [26] return [26]# 返回兩個列表后這兩個返回值將作為merge_sort [54, 26]的函數(shù)體接著往下執(zhí)行函數(shù)即：# left_li = [54]# right_li = [26]# result = [26, 54]# return result merge_sort [54, 26]執(zhí)行完畢接下來執(zhí)行 right_li = merge_sort([93, 17])（得到最底層的結(jié)果后一步步往外面解遞歸嵌套）## right_li = merge_sort([93, 17])## left_li = merge_sort([93])## return [93]# left_li =[93]## right_li = merge_sort([17])## return [17]# right_li = [17]## result = [17, 93]## return result## right_li = [17, 93]## result = [17, 26, 54, 93]## return result## left_li = [17, 26, 54, 93]## right_li = merge_sort([77, 31, 44, 55, 20])### result = []# return result

7、二分法查找

原理：
二分查找又稱折半查找，優(yōu)點是比較次數(shù)少，查找速度快，平均性能好；其缺點是要求待查表為有序表，且插入刪除困難。因此，折半查找方法適用于不經(jīng)常變動而查找頻繁的有序列表。首先，假設(shè)表中元素是按升序排列，將表中間位置記錄的關(guān)鍵字與查找關(guān)鍵字比較，如果兩者相等，則查找成功；否則利用中間位置記 錄將表分成前、后兩個子表，如果中間位置記錄的關(guān)鍵字大于查找關(guān)鍵字，則進一步查找前一子表，否則進一步查找后一子表。重復(fù)以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。
二分法查找分析：

時間復(fù)雜度
最優(yōu)時間復(fù)雜度：O(1)
最壞時間復(fù)雜度：O(logn)
代碼實現(xiàn)：

# coding:utf-8 # [17, 20, 26, 31, 44, 54, 55, 77, 93] # mid = n/2 # # [17, 20, 26, 31] # mid = n/2def binary_search(alist, item):"""二分查找,遞歸"""n = len(alist)if n > 0:mid = n//2if alist[mid] == item:return Trueelif item < alist[mid]:return binary_search(alist[:mid], item)else:return binary_search(alist[mid+1:], item)return Falsedef binary_search_2(alist, item):"""二分查找， 非遞歸"""n = len(alist)first = 0last = n-1while first <= last:mid = (first + last)//2if alist[mid] == item:return Trueelif item < alist[mid]:last = mid - 1else:first = mid + 1return False

總結(jié)

各種算法時間復(fù)雜對對比：

總結(jié)

以上是生活随笔為你收集整理的常见算法详解（原理及代码实现Python版本）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。