1. 程式人生 > >數據結構與算法 - 排序與搜索

數據結構與算法 - 排序與搜索

part -s point 指向 一次 search 算法 earch 二分查找

排序與搜索

排序算法(英語:Sorting algorithm)是一種能將一串數據依照特定順序進行排列的一種算法。

1.冒泡排序

冒泡排序(英語: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)
  • 穩定性:穩定

冒泡排序的演示

效果:

技術分享圖片
冒泡排序

2.選擇排序

選擇排序(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)
  • 穩定性:不穩定(考慮升序每次選擇最大的情況)

選擇排序演示

技術分享圖片
選擇排序

3.插入排序

插入排序(英語: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)
  • 穩定性:穩定

插入排序演示

技術分享圖片
插入排序

4.快速排序

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

  • 步驟為:

  • 1.從數列中挑出一個元素,稱為"基準"(pivot),

  • 2.重新排序數列,所有元素比基準值小的擺放在基準前面,所有元素比基準值大的擺在基準的後面(相同的數可以到任一邊)。在這個分區結束之後,該基準就處於數列的中間位置。這個稱為分區(partition)操作。
    遞歸地(recursive)把小於基準值元素的子數列和大於基準值元素的子數列排序。

  • 3.遞歸的最底部情形,是數列的大小是零或一,也就是永遠都已經被排序好了。雖然一直遞歸下去,但是這個算法總會結束,因為在每次的叠代(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)時間。

快速排序演示

技術分享圖片
快速排序

5.希爾排序

希爾排序(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步長進行排序(此時就是簡單的插入排序了)

希爾排序的分析

技術分享圖片
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)
  • 穩定想:不穩定

希爾排序演示

技術分享圖片
希爾排序

6.歸並排序

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

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

歸並排序的分析

技術分享圖片
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 = merge_sort(alist)
print(sorted_alist)

時間復雜度

  • 最優時間復雜度:O(nlogn)
  • 最壞時間復雜度:O(nlogn)
  • 穩定性:穩定

7.常見排序算法效率比較

技術分享圖片

8.搜索

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

二分法查找

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

技術分享圖片

二分法查找實現

(非遞歸實現)

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)



數據結構與算法 - 排序與搜索