Python數據結構與算法（幾種排序）

時間 2019-11-12

原文原文鏈接

數據結構與算法（Python）

冒泡排序

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

冒泡排序算法的運做以下：shell

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

冒泡排序的分析

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

那麼咱們須要進行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)
穩定性：穩定

冒泡排序的演示

效果：app

選擇排序

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

選擇排序的主要優勢與數據移動有關。若是某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，所以對n個元素的表進行排序總共進行至多n-1次交換。在全部的徹底依靠交換去移動元素的排序方法中，選擇排序屬於很是好的一種。ui

選擇排序分析

排序過程：spa

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

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