常用排序與插入算法

冒泡排序

冒泡排序（英語：Bubble Sort）是一種簡單的排序算法。它重復地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

冒泡排序算法的運作如下：

比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。

對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。這步做完后，最后的元素會是最大的數。

針對所有的元素重復以上的步驟，除了最后一個。

持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

冒泡排序的分析

交換過程圖示(第一次)：

代碼如下：

defbubble_sort(li):for i in range(len(li) - 1):for j in range(len(li) - i - 1):if li[j] > li[j+1]:

li[j], li[j+1] = li[j+1], li[j]returnli

list1= [15, 66, 20, 350, 464, 88, 995, 100]print(bubble_sort(list1))

時間復雜度

最優時間復雜度：O(n) （表示遍歷一次發現沒有任何可以交換的元素，排序結束。）

最壞時間復雜度：O(n2)

穩定性：穩定

冒泡排序的演示

效果：

選擇排序

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

選擇排序的主要優點與數據移動有關。如果某個元素位于正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬于非常好的一種。

選擇排序分析

排序過程：

紅色表示當前最小值，黃色表示已排序序列，藍色表示當前位置。

defselection_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]

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(n2)

最壞時間復雜度：O(n2)

穩定性：不穩定（考慮升序每次選擇最大的情況）

選擇排序演示

插入排序

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

插入排序分析

definsert_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)

穩定性：穩定

插入排序演示

快速排序

快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

步驟為：

從數列中挑出一個元素，稱為"基準"（pivot），

重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數可以到任一邊）。在這個分區結束之后，該基準就處于數列的中間位置。這個稱為分區（partition）操作。

遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序。

遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最后的位置去。

快速排序的分析

defquick_sort(alist, start, end):"""快速排序"""

#遞歸的退出條件

if start >=end:return

#設定起始元素為要尋找位置的基準元素

mid=alist[start]#low為序列左邊的由左向右移動的游標

low=start#high為序列右邊的由右向左移動的游標

high=endwhile low

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]

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)

穩定性：不穩定

從一開始快速排序平均需要花費O(n log n)時間的描述并不明顯。但是不難觀察到的是分區運算，數組的元素都會在每次循環中走訪過一次，使用O(n)的時間。在使用結合（concatenation）的版本中，這項運算也是O(n)。

在最好的情況，每次我們運行一次分區，我們會把一個數列分為兩個幾近相等的片段。這個意思就是每次遞歸調用處理一半大小的數列。因此，在到達大小為一的數列前，我們只要作log n次嵌套的調用。這個意思就是調用樹的深度是O(log n)。但是在同一層次結構的兩個程序調用中，不會處理到原來數列的相同部分；因此，程序調用的每一層次結構總共全部僅需要O(n)的時間（每個調用有某些共同的額外耗費，但是因為在每一層次結構僅僅只有O(n)個調用，這些被歸納在O(n)系數中）。結果是這個算法僅需使用O(n log n)時間。

快速排序演示

希爾排序

希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因DL．Shell于1959年提出而得名。 希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

希爾排序過程

希爾排序的基本思想是：將數組列在一個表中并對列分別進行插入排序，重復這過程，不過每次用更長的列（步長更長了，列數更少了）來進行。最后整個表就只有一列了。將數組轉換至表是為了更好地理解這算法，算法本身還是使用數組進行排序。

例如，假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序，我們可以通過將這列表放在有5列的表中來更好地描述算法，這樣他們就應該看起來是這樣(豎著的元素是步長組成)：

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

將上述四行數字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。這時10已經移至正確位置了，然后再以3為步長進行排序：

10 14 73

25 23 13

27 94 33

39 25 59

94 65 82

45

排序之后變為：

10 14 13

25 23 33

27 25 59

39 65 73

45 94 82

94

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

希爾排序的分析

defshell_sort(alist):

n=len(alist)#初始步長

gap= n / 2

while gap >0:#按步長進行插入排序

for i inrange(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 / 2alist= [54,26,93,17,77,31,44,55,20]

shell_sort(alist)print(alist)

時間復雜度

最優時間復雜度：根據步長序列的不同而不同

最壞時間復雜度：O(n2)

穩定想：不穩定

希爾排序演示

歸并排序

歸并排序是采用分治法的一個非常典型的應用。歸并排序的思想就是先遞歸分解數組，再合并數組。

將數組分解最小之后，然后合并兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了后相應的指針就往后移一位。然后再比較，直至一個數組為空，最后把另一個數組的剩余部分復制過來即可。

歸并排序的分析

defmerge(li, low, mid, high):

i=low

j= mid + 1ltmp=[]while i <= mid and j <=high:if li[i]

ltmp.append(li[i])

i+= 1

else:

ltmp.append(li[j])

j+= 1

while i <=mid:

ltmp.append(li[i])

i+= 1

while j <=high:

ltmp.append(li[j])

j+= 1li[low:high+1] =ltmpdef_mergesort(li, low, high):if low

mid= (low + high) // 2_mergesort(li,low, mid)

_mergesort(li, mid+1, high)

merge(li, low, mid, high)

時間復雜度

最優時間復雜度：O(nlogn)

最壞時間復雜度：O(nlogn)

穩定性：穩定

堆排序

堆

在這里首先要先解釋一下什么是堆，堆棧是計算機的兩種最基本的數據結構。堆的特點就是FIFO(first in first out)先進先出，這里的話我覺得可以理解成樹的結構。堆在接收數據的時候先接收的數據會被先彈出。

棧的特性正好與堆相反，是屬于FILO(first in/last out)先進后出的類型。棧處于一級緩存而堆處于二級緩存中。這個不是本文重點所以不做過多展開。

堆排序節點訪問和操作定義

堆節點的訪問

在這里我們借用wiki的定義來說明：

通常堆是通過一維數組來實現的。在陣列起始位置為0的情況中

(1)父節點i的左子節點在位置(2*i+1);

(2)父節點i的右子節點在位置(2*i+2);

(3)子節點i的父節點在位置floor((i-1)/2);

堆操作

堆可以分為大根堆和小根堆，這里用最大堆的情況來定義操作:

(1)最大堆調整(MAX_Heapify):將堆的末端子節點作調整，使得子節點永遠小于父節點。這是核心步驟，在建堆和堆排序都會用到。比較i的根節點和與其所對應i的孩子節點的值。當i根節點的值比左孩子節點的值要小的時候，就把i根節點和左孩子節點所對應的值交換，當i根節點的值比右孩子的節點所對應的值要小的時候，就把i根節點和右孩子節點所對應的值交換。然后再調用堆調整這個過程，可見這是一個遞歸的過程。

(2)建立最大堆(Build_Max_Heap):將堆所有數據重新排序。建堆的過程其實就是不斷做最大堆調整的過程，從len/2出開始調整，一直比到第一個節點。

(3)堆排序(HeapSort):移除位在第一個數據的根節點，并做最大堆調整的遞歸運算。堆排序是利用建堆和堆調整來進行的。首先先建堆，然后將堆的根節點選出與最后一個節點進行交換，然后將前面len-1個節點繼續做堆調整的過程。直到將所有的節點取出，對于n個數我們只需要做n-1次操作。

這里用網上的一張直觀圖來感受一下

defsift(data, low, high):

i=low

j= 2 * i + 1tmp=data[i]while j <= high: #只要沒到子樹的最后

if j+1 <= high and data[j] < data[j + 1]: #如果有右孩子且比左孩子大

j+= 1 #就把j指向右孩子

if tmp < data[j]:#如果領導不能干

data[i] = data[j] #小領導上位

i =j

j= 2 * i + 1

else:breakdata[i]=tmpdefheap_sort(data):

n=len(data)for i in range(n // 2 - 1, -1, -1):

sift(data, i, n- 1)for i in range(n - 1, -1, -1):

data[0], data[i]=data[i], data[0]

sift(data, 0, i- 1)

查找算法

搜索是在一個項目集合中找到一個特定項目的算法過程。搜索通常的答案是真的或假的，因為該項目是否存在。 搜索的幾種常見方法：順序查找、二分法查找、二叉樹查找、哈希查找

二分法查找

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

二分法查找實現

（非遞歸實現）

defbinary_search(alist, item):

first=0

last= len(alist)-1

while first<=last:

midpoint= (first + last)/2

if alist[midpoint] ==item:returnTrueelif item

last= midpoint-1

else:

first= midpoint+1

returnFalse

testlist= [0, 1, 2, 8, 13, 17, 19, 32, 42,]print(binary_search(testlist, 3))print(binary_search(testlist, 13))

（遞歸實現）defbinary_search(alist, item):if len(alist) ==0:returnFalseelse:

midpoint= len(alist)//2

if alist[midpoint]==item:returnTrueelse:if item

testlist= [0, 1, 2, 8, 13, 17, 19, 32, 42,]print(binary_search(testlist, 3))print(binary_search(testlist, 13))

時間復雜度

最優時間復雜度：O(1)

最壞時間復雜度：O(logn)

python

算法時間復雜度總結

總結

以上是生活随笔為你收集整理的python实现排序算法_数据结构之（3）python实现排序算法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。