排序與搜索

時間 2020-05-26

標籤排序搜索简体版

原文原文鏈接

1. 排序

1.1 冒泡排序算法

1.2 選擇排序shell

1.3 插入排序數組

1.4 希爾排序app

1.5 快速排序性能

1.6 歸併排序優化

1. 排序

排序算法（英語：Sorting algorithm）是一種能將一串數據依照特定順序進行排列的一種算法。ui

排序算法的穩定性

穩定性：穩定排序算法會讓本來有相等鍵值的紀錄維持相對次序。也就是若是一個排序算法是穩定的，當有兩個相等鍵值的紀錄R和S，且在本來的列表中R出如今S以前，在排序過的列表中R也將會是在S以前。spa

當相等的元素是沒法分辨的，好比像是整數，穩定性並非一個問題。然而，假設如下的數對將要以他們的第一個數字來排序。3d

(4, 1) (3, 1) (3, 7) (5, 6)

在這個情況下，有可能產生兩種不一樣的結果，一個是讓相等鍵值的紀錄維持相對的次序，而另一個則沒有：指針

(3, 1) (3, 7) (4, 1) (5, 6)  （維持次序）
(3, 7) (3, 1) (4, 1) (5, 6)  （次序被改變）

不穩定排序算法可能會在相等的鍵值中改變紀錄的相對次序，可是穩定排序算法歷來不會如此。不穩定排序算法能夠被特別地實現爲穩定。做這件事情的一個方式是人工擴充鍵值的比較，如此在其餘方面相同鍵值的兩個對象間之比較，（好比上面的比較中加入第二個標準：第二個鍵值的大小）就會被決定使用在原先數據次序中的條目，看成一個同分決賽。然而，要記住這種次序一般牽涉到額外的空間負擔。

常見算法效率比較

性能從優到劣：

1.1 冒泡排序

介紹

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

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

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

交換過程圖示（第一次遍歷）

那麼咱們須要進行n-1次冒泡過程，每次對應的比較次數以下圖所示：

演示效果

代碼實現

 1 def bubble_sort(alist):
 2     "冒泡排序"
 3     n = len(alist)
 4     for j in range(n-1):  # 控制遍歷的次數（圖示中的Pass）
 5         count = 0
 6         for i in range(n-1-j):  # 每次遍歷須要比較的次數，逐漸減小（圖示中的Comparisons）
 7             if alist[i] > alist[i+1]:
 8                 alist[i], alist[i+1] = alist[i+1], alist[i]
 9             count += 1
10         # 優化算法複雜度，若第一遍遍歷時沒有交換元素，即表明元素自己已排好序。例如[1, 2, 3]
11         # 無需再進行第二次遍歷，便可直接退出
12         if count == 0:
13             return
14 
15                 
16 # j: 0     i: range(n-1-0) = n-1
17 # j: 1     i: range(n-1-1) = n-2
18 # j: 2     i: range(n-1-2) = n-3
19 # ...
20 # j: n-2   i: range(n-1-(n-2)) = 1
21 
22 
23 if __name__ == "__main__":
24     li = [1, 21, 4, 2, 56, 2, 34, 67]
25     bubble_sort(li)
26     print(li)  # [1, 2, 2, 4, 21, 34, 56, 67]

時間複雜度

最優時間複雜度：O(n)（表示第一次遍歷發現沒有任何能夠交換的元素，則排序結束）
最壞時間複雜度：O(n^2)
穩定性：穩定

1.2 選擇排序

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工做原理以下：

在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。
以此類推，直到全部元素均排序完畢。

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

排序過程圖示

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

演示效果

代碼實現

 1 def selected_sort(alist):
 2     n = len(alist)
 3     # 須要進行n-1次選擇操做
 4     for i in range(n-1):
 5         # 記錄最小位置
 6         min_index = i
 7         # 從i+1位置到末尾，選擇出最小的元素
 8         for j in range(i+1, n):
 9             if alist[j] < alist[min_index]:
10                 min_index = j
11         # 若是選擇出的元素不在正確位置，進行交換
12         if min_index != i:
13             alist[i], alist[min_index] = alist[min_index], alist[i]
14 
15 
16 alist = [54, 226, 93, 17, 77, 31, 44, 55, 20]
17 selected_sort(alist)
18 print(alist)

時間複雜度

最優時間複雜度：O(n^2)
最壞時間複雜度：O(n^2)
穩定性：不穩定（考慮升序每次選擇最大的狀況）

1.3 插入排序

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

排序過程圖示

演示效果

代碼實現

 1 def insert_sort(alist):
 2     n = len(alist)
 3     # 從第二個位置開始（未排序數據），即把下標爲1的元素開始向前插入（有序數據）
 4     for i in range(1, n):
 5         # 從第i個元素開始向前比較，若是小於前一個元素，則交換
 6         for j in range(i, 0, -1):
 7             if alist[j] < alist[j-1]:
 8                 alist[j], alist[j-1] = alist[j-1], alist[j]
 9 
10 
11 alist = [54, 226, 93, 17, 77, 31, 44, 55, 20]
12 insert_sort(alist)
13 print(alist)

時間複雜度

最優時間複雜度：O(n)（升序排列，序列已經處於升序狀態）
最壞時間複雜度：O(n^2)
穩定性：穩定

1.4 希爾排序

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

示例分析

演示效果

代碼實現

 1 def shell_sort(alist):
 2     n = len(alist)
 3     # 初始步長
 4     gap = n / 2
 5     while gap > 0:
 6         # 按步長進行插入排序
 7         for i in range(gap, n):
 8             j = i
 9             # 插入排序
10             while j>=gap and alist[j-gap] > alist[j]:
11                 alist[j-gap], alist[j] = alist[j], alist[j-gap]
12                 j -= gap
13         # 獲得新的步長
14         gap = gap / 2
15 
16 alist = [54,26,93,17,77,31,44,55,20]
17 shell_sort(alist)
18 print(alist)

時間複雜度

最優時間複雜度：根據步長序列的不一樣而不一樣
最壞時間複雜度：O(n2)
穩定想：不穩定

1.5 快速排序

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

步驟爲：

從數列中挑出一個元素，稱爲「基準」(pivot)。
從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區結束以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做。
遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

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

排序過程圖示

演示效果

代碼實現

方式一：改變原列表

 1 def quick_sort(alist, start, end):
 2     # 遞歸的退出條件
 3     if start >= end:
 4         return
 5     # 設定起始元素爲要尋找位置的基準元素
 6     mid = alist[start]
 7     # low爲從左往右的遊標
 8     low = start
 9     # high爲從右往左的遊標
10     high = end
11     # 當low與high未重合
12     while low < high:
13         # 當low與high未重合時，若high指向的元素不比基準元素小，則high向左移動一位
14         while low < high and alist[high] >= mid:
15             high -= 1
16         # 若high指向的元素比基準元素小，則推出循環，交換元素位置
17         alist[low] = alist[high]
18         # 當low與high未重合時，若low指向的元素比基準元素小，則low向右移動一位
19         while low < high and alist[low] < mid:
20             low += 1
21         # 若low指向的元素比基準元素大，則推出循環，交換元素位置
22         alist[high] = alist[low]
23     # 當low與high重合，推出循環，此時所指位置爲基準元素的正確位置
24     # 將基準元素放到該位置
25     alist[low] = mid
26     # 對基準元素左邊的子序列進行快速排序
27     quick_sort(alist, start, low-1)
28     # 對基準元素右邊的子序列進行快速排序
29     quick_sort(alist, low+1, end)
30 
31 
32 alist = [54, 226, 93, 17, 77, 31, 44, 55, 20]
33 quick_sort(alist, 0, len(alist)-1)
34 print(alist)

方式二：不改變原列表

 1 def quick_sort(alist):
 2     if len(alist) <= 1:
 3         return alist
 4     mid = alist[0]
 5     left = [x for x in alist if x < mid]
 6     right = [x for x in alist if x > mid]
 7     return quick_sort(left) + [mid] + quick_sort(right)
 8 
 9 
10 alist = [54, 226, 93, 17, 77, 31, 44, 55, 20]
11 print(quick_sort(alist))

時間複雜度

最優時間複雜度：O(nlogn)
最壞時間複雜度：O(n^2)
穩定性：不穩定

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

在最好的狀況，每次咱們運行一次分區，咱們會把一個數列分爲兩個幾近相等的片斷。這個意思就是每次遞歸調用處理一半大小的數列。所以，在到達大小爲一的數列前，咱們只要做log n次嵌套的調用。這個意思就是調用樹的深度是O(log n)。可是在同一層次結構的兩個程序調用中，不會處理到原來數列的相同部分；所以，程序調用的每一層次結構總共所有僅須要O(n)的時間（每一個調用有某些共同的額外耗費，可是由於在每一層次結構僅僅只有O(n)個調用，這些被概括在O(n)係數中）。結果是這個算法僅需使用O(nlogn)時間。

1.6 歸併排序

歸併排序是採用分治法的一個很是典型的應用。歸併排序的思想就是先遞歸分解數組，再合併數組。

將數組分解最小以後，而後合併兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了後相應的指針就日後移一位。而後再比較，直至一個數組爲空，最後把另外一個數組的剩餘部分複製過來便可。

歸併排序的分析

代碼實現

 1 def merge_sort(alist):
 2     """歸併排序"""
 3     n = len(alist)
 4     if n <= 1:
 5         return alist
 6     mid = n // 2
 7     # left 採用歸併排序後造成的有序的新的列表
 8     left_li = merge_sort(alist[:mid])
 9     # right 採用歸併排序後造成的有序的新的列表
10     right_li = merge_sort(alist[mid:])
11 
12     # 將兩個有序的子序列合併爲一個新的總體
13     # merge(left, right)
14     left_pointer, right_pointer = 0, 0
15     result = []
16 
17     while left_pointer < len(left_li) and right_pointer < len(right_li):
18         if left_li[left_pointer] <=  right_li[right_pointer]:
19             result.append(left_li[left_pointer])
20             left_pointer += 1
21         else:
22             result.append(right_li[right_pointer])
23             right_pointer += 1
24 
25     result += left_li[left_pointer:]
26     result += right_li[right_pointer:]
27     return result
28 
29 
30 if __name__ == "__main__":
31     li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
32     print(li)
33     sorted_li = merge_sort(li)
34     print(li)
35     print(sorted_li)

時間複雜度

最優時間複雜度：O(nlogn)
最壞時間複雜度：O(nlogn)
穩定性：穩定

2. 搜索

搜索是在一個項目集合中找到一個特定項目的算法過程。搜索一般的答案是真的或假的，判斷該項目是否存在。

搜索的幾種常見方法：順序查找、二分法查找、二叉樹查找、哈希查找等。

二分法查找

二分查找又稱折半查找，優勢是比較次數少，查找速度快，平均性能好；其缺點是要求待查表爲有序表，且插入刪除困難。所以，折半查找方法適用於不常常變更而查找頻繁的有序列表。

算法步驟：

首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查找關鍵字比較，若是二者相等，則查找成功。
不然利用中間位置記錄將表分紅前、後兩個子表，若是中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，不然進一步查找後一子表。
重複以上過程，直到找到知足條件的記錄，使查找成功，或直到子表不存在爲止，此時查找不成功。

代碼實現

方式一：遞歸實現

 1 def binary_search(alist, item):
 2     """二分查找法：遞歸實現"""
 3     n = len(alist)
 4     if n > 0:
 5         mid = n // 2
 6         if item == alist[mid]:
 7             return True
 8         elif item < alist[mid]:
 9             return binary_search(alist[:mid], item)
10         else:
11             return binary_search(alist[mid+1:], item)
12     # n=0，即未找到該元素
13     return False
14 
15 
16 if __name__ == '__main__':
17     li = [1, 2, 34, 45, 65, 78]
18     print(binary_search(li, 2))  # True
19     print(binary_search(li, 44))  # False

方式二：非遞歸實現

 1 def binary_search(alist, item):
 2     """二分查找法：非遞歸實現"""
 3     n = len(alist)
 4     first = 0  # 第一個下標
 5     last = n - 1  # 最後一個下標
 6     while first <= last:
 7         mid = (first + last) // 2  # 中間下標
 8         if item == alist[mid]:
 9             return True
10         elif item < alist[mid]:
11             last = mid - 1
12         else:
13             first = mid + 1
14     return False
15 
16 
17 if __name__ == '__main__':
18     li = [1, 2, 34, 45, 65, 78]
19     print(binary_search(li, 2))  # True
20     print(binary_search(li, 44))  # False

時間複雜度

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

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。