Python數據結構與算法

阿新 • • 發佈：2018-07-16

alt 需要二叉次數 num 頻繁繼續指針在一起

數據結構與算法（Python）

冒泡排序

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

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

比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
針對所有的元素重復以上的步驟，除了最後一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

冒泡排序的分析

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

技術分享圖片

那麽我們需要進行n-1次冒泡過程，每次對應的比較次數如下圖所示：

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)
穩定性：穩定

冒泡排序的演示

效果：

技術分享圖片

選擇排序

選擇排序（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(n2)
最壞時間復雜度：O(n2)
穩定性：不穩定（考慮升序每次選擇最大的情況）

選擇排序演示

插入排序

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

插入排序分析

技術分享圖片

def 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)
穩定性：穩定

插入排序演示

快速排序

快速排序（英語：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)
穩定性：不穩定

從一開始快速排序平均需要花費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為步長進行排序：

排序之後變為：

最後以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)
穩定想：不穩定

希爾排序演示

歸並排序

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

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

歸並排序的分析

技術分享圖片

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)
穩定性：穩定

搜索

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

二分法查找

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

技術分享圖片

二分法查找實現

（非遞歸實現）

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

（遞歸實現）
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))

時間復雜度

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

Python數據結構與算法

Python數據結構與算法

數據結構與算法（Python）

冒泡排序

冒泡排序的分析

時間復雜度

冒泡排序的演示

選擇排序

選擇排序分析

時間復雜度

選擇排序演示

插入排序

插入排序分析

時間復雜度

插入排序演示

快速排序

快速排序的分析

時間復雜度

快速排序演示

希爾排序

希爾排序過程

希爾排序的分析

時間復雜度

希爾排序演示

歸並排序

歸並排序的分析

時間復雜度

搜索

二分法查找

二分法查找實現

（非遞歸實現）

時間復雜度

相關推薦