查詢演算法是用來檢索序列資料（群體）中是否存在給定的資料（關鍵字），常用查詢演算法有：
- 線性查詢：
線性查詢也稱為順序查詢，用於在無序數列中查詢。 - 二分查詢：
二分查詢也稱為折半查詢，其演算法用於有序數列。 - 插值查詢：
插值查詢是對二分查詢演算法的改進。 - 分塊查詢： 又稱為
索引順序查詢，它是線性查詢的改進版本。 - 樹表查詢：
樹表查詢又可分二叉查詢樹、平衡二叉樹查詢。 - 雜湊查詢：
雜湊查詢可以直接通過關鍵字查詢到所需要資料。
因樹表查詢、雜湊查詢的所需篇幅較多，就不在本文講解。本文將詳細介紹除樹表、雜湊之外的查詢演算法，並分析每一種演算法的優點和缺點，並提出相應的優化方案。
1. 線性查詢
線性查詢也稱為順序查詢，線性查詢屬於原始、窮舉、暴力查詢演算法。容易理解、編碼實現也簡單。但是在資料量較多時，因其演算法思想是樸素、窮舉的，演算法中沒有太多優化設計，效能會很低下。
線性查詢思想：
- 從頭至尾逐一掃描原始列表中的每一個資料，並和給定的關鍵字進行比較。
- 如果比較相等，則查詢成功。
- 當掃描結束後，仍然沒有找到與給定關鍵字相等的資料，則宣佈查詢失敗。
根據線性查詢演算法的描述，很容易編碼實現：
'''
線性查詢演算法
引數：
nums: 序列
key:關鍵字
返回值：
關鍵字在序列中的位置
如果沒有，則返回 -1
'''
def line_find(nums, key):
for i in range(len(nums)):
if nums[i] == key:
return i
return -1
'''
測試線性演算法
'''
if __name__ == "__main__":
nums = [4, 1, 8, 10, 3, 5]
key = int(input("請輸入要查詢的關鍵字："))
pos = line_find(nums, key)
print("關鍵字 {0} 在數列的第 {1} 位置".format(key, pos))
'''
輸出結果：
請輸入要查詢的關鍵字：3
關鍵字 3 在數列的 4 位置
'''
線性查詢演算法的平均時間複雜度分析。
-
運氣最好的情況：如果要查詢的關鍵字恰好在數列的第
1個位置，則只需要查詢 1 次就可以了。如在數列=
[4,1,8,10,3,5]中查詢關鍵字4。只需要查詢
1次。 -
運氣最不好的情況：一至掃描到數列最尾部時，才找到關鍵字。
如在數列=
[4,1,8,10,3,5]中查詢是否存在關鍵字5。則需要查詢的次數等於數列的長度，此處即為
6次。 -
運氣不好不壞：如果要查詢的關鍵字在數列的中間某個位置，則查詢的概率是
1/n。n為數列長度。
線性查詢的平均查詢次數應該=(1+n)/2。換成大 O 表示法則為 O(n) 。
大
O表示法中忽視常量。
線性查詢最糟糕情況是：掃描完整個數列後，沒有所要查詢的關鍵字。
如在數列=
[4,1,8,10,3,5]中查詢是否存在關鍵字12。掃描了
6次後，鎩羽而歸！！
改良線性查詢演算法
可以對線性查詢演算法進行相應的優化。如設定“前哨站”。所謂“前哨站”，就是把要查詢的關鍵字在查詢之前插入到數列的尾部。
def line_find_(nums, key):
i = 0
while nums[i] != key:
i += 1
return -1 if i == len(nums)-1 else i
'''
測試線性演算法
'''
if __name__ == "__main__":
nums = [4, 1, 8, 10, 3, 5]
key = int(input("請輸入要查詢的關鍵字："))
# 查詢之前，先把關鍵字儲存到列到的尾部
nums.append(key)
pos = line_find_(nums, key)
print("關鍵字 {0} 在數列的第 {1} 位置".format(key, pos))
用"前哨站"優化後的線性查詢演算法的時間複雜度沒有變化，O(n)。或者說從 2 者程式碼上看，也沒有太多變化。
但從程式碼的實際執行角度而言，第 2 種方案減少了 if 指令的次數，同樣減少了編譯後的指令，也就減少了 CPU執行指令的次數，這種優化屬於微優化，不是演算法本質上的優化。
使用計算機程式語言所編寫的程式碼為偽指令程式碼。
經過編譯後的指令程式碼叫
CPU指令集。有一種優化方案就是減少編譯後的指令集。
2. 二分查詢
二分查詢屬於有序查詢，所謂有序查詢，指被查詢的數列必須是有序的。如在數列=[4,1,8,10,3,5,12]中查詢是否存在關鍵字 4 ，因數列不是有序的，所以不能使用二分查詢，如果要使用二分查詢演算法，則需要先對數列進行排序。
二分查詢使用了二分（折半）演算法思想，二分查詢演算法中有 2 個關鍵資訊需要隨時獲取：
- 一個是數列的中間位置
mid_pos。 - 一個是數列的中間值
mid_val。
現在通過在數列 nums=[1,3,4,5,8,10,12] 中查詢關鍵字 8來了解二分查詢的演算法流程。
在進行二分查詢之前，先定義 2 個位置（指標）變數：
- 左指標
l_idx初始指向數列的最左邊數字。 - 右指標
r_idx初始指向數列的最右邊數字。
第 1 步：通過左、右指標的當前位置計算出數列的中間位置 mid_pos=3，並根據 mid_pos 的值找出數列中間位置所對應的值 mid_val=nums[mid_pos] 是 5。
二分查詢演算法的核心就是要找出數列中間位置的值。
第 2 步：把數列中間位置的值和給定的關鍵字相比較。這裡關鍵字是 8，中間位置的值是 5，顯然 8 是大於 5，因為數列是有序的，自然會想到沒有必要再與數列中 5 之前的數字比較，而是專心和 5 之後的數字比較。
一次比較後再次查詢的數列範圍縮小了一半。這也是二分演算法的由來。
第 3 步：根據比較結果，調整數列的大小，這裡的大小調整不是物理結構上調整，而是邏輯上調整，調整後原數列沒有變化。也就是通過修改左指標或右指標的位置，從邏輯上改變數列大小。調整後的數列如下圖。
二分查詢演算法中數列的範圍由左指標到右指標的長度決定。
第 4 步：重複上述步驟，至到找到或找不到為止。
編碼實現二分查詢演算法
'''
二分查詢演算法
'''
def binary_find(nums, key):
# 初始左指標
l_idx = 0
# 初始在指標
r_ldx = len(nums) - 1
while l_idx <= r_ldx:
# 計算出中間位置
mid_pos = (r_ldx + l_idx) // 2
# 計算中間位置的值
mid_val = nums[mid_pos]
# 與關鍵字比較
if mid_val == key:
# 出口一：比較相等，有此關鍵字，返回關鍵字所在位置
return mid_pos
elif mid_val > key:
# 說明查詢範圍應該縮少在原數的左邊
r_ldx = mid_pos - 1
else:
l_idx = mid_pos + 1
# 出口二：沒有查詢到給定關鍵字
return -1
'''
測試二分查詢
'''
if __name__ == "__main__":
nums = [1, 3, 4, 5, 8, 10, 12]
key = 3
pos = binary_find(nums, key)
print(pos)
通過前面對二分演算法流程的分析，可知二分查詢的子問題和原始問題是同一個邏輯，所以可以使用遞迴實現：
'''
遞迴實現二分查詢
'''
def binary_find_dg(nums, key, l_idx, r_ldx):
if l_idx > r_ldx:
# 出口一：沒有查詢到給定關鍵字
return -1
# 計算出中間位置
mid_pos = (r_ldx + l_idx) // 2
# 計算中間位置的值
mid_val = nums[mid_pos]
# 與關鍵字比較
if mid_val == key:
# 出口二：比較相等，有此關鍵字，返回關鍵字所在位置
return mid_pos
elif mid_val > key:
# 說明查詢範圍應該縮少在原數的左邊
r_ldx = mid_pos - 1
else:
l_idx = mid_pos + 1
return binary_find_dg(nums, key, l_idx, r_ldx)
'''
測試二分查詢
'''
if __name__ == "__main__":
nums = [1, 3, 4, 5, 8, 10, 12]
key = 8
pos = binary_find_dg(nums, key,0,len(nums)-1)
print(pos)
二分查詢效能分析：
二分查詢的過程用樹形結構描述會更直觀，當搜尋完畢後，繪製出來樹結構是一棵二叉樹。
- 如上述程式碼執行過程中，先找到數列中的中間數字
5，然後以5為根節點構建唯一結點樹。
5和關鍵字8比較後，再在以數字5為分界線的右邊數列中找到中間數字10，樹形結構會變成下圖所示。
10和關鍵字8比較後，再在10的左邊查詢。
查詢到8 後，意味著二分查詢已經找到結果，只需要 3 次就能查詢到最終結果。
從二叉樹的結構上可以直觀得到結論：二分查詢關鍵字的次數由關鍵字在二叉樹結構中的深度決定。
- 上述是查詢給定的數字
8，為了能查詢到數列中的任意一個數字，最終完整的樹結構應該如下圖所示。
很明顯，樹結構是標準的二叉樹。從樹結構上可以看出，無論查詢任何數字，最小是 1 次，如查詢數字 5，最多也只需要 3 次，比線性查詢要快很多。
根據二叉樹的特性，結點個數為 n 的樹的深度為 h=log2(n+1)，所以二分查詢演算法的大 O 表示的時間複雜度為 O(logn)，是對數級別的時間度。
當對長度為1000的數列進行二分查詢時，所需次數最多隻要 10 次，二分查詢演算法的效率顯然是高效的。
但是，二分查詢需要對數列提前排序，前面的時間複雜度是沒有考慮排序時間的。所以，二分查詢一般適合數字變化穩定的有序數列。
3. 插值查詢
插值查詢本質是二分查詢，插值查詢對二分查詢演算法中查詢中間位置的計算邏輯進行了改進。
原生二分查詢演算法中計算中間位置的邏輯：中間位置等於左指標位置加上右指標位置然後除以 2。
# 計算中間位置
mid_pos = (r_ldx + l_idx) // 2
插值演算法計算中間位置邏輯如下所示：
key為要查詢的關鍵字！！
# 插值演算法中計算中間位置
mid_pos = l_idx + (key - nums[l_idx]) // (nums[r_idx] - nums[l_idx]) * (r_idx - l_idx)
編碼實現插值查詢：
# 插值查詢基於二分法，只是mid計算方法不同
def binary_search(nums, key):
l_idx = 0
r_idx = len(nums) - 1
old_mid = -1
mid_pos = None
while l_idx < r_idx and nums[0] <= key and nums[r_idx] >= key and old_mid != mid_pos:
# 中間位置計算
mid_pos = l_idx + (key - nums[l_idx]) // (nums[r_idx] - nums[l_idx]) * (r_idx - l_idx)
old_mid = mid_pos
if nums[mid_pos] == key:
return "index is {}, target value is {}".format(mid_pos, nums[mid_pos])
# 此時目標值在中間值右邊，更新左邊界位置
elif nums[mid_pos] < key:
l_idx = mid_pos + 1
# 此時目標值在中間值左邊，更新右邊界位置
elif nums[mid_pos] > key:
r_idx = mid_pos - 1
return "Not find"
li =[1, 3, 4, 5, 8, 10, 12]
print(binary_search(li, 6))
插值演算法的中間位置計算時，對中間位置的計算有可能多次計算的結果是一樣的，此時可以認為查詢失敗。
插值演算法的效能介於線性查詢和二分查詢之間。
當數列中數字較多且分佈又比較均勻時，插值查詢演算法的平均效能比折半查詢要好的多。如果數列中資料分佈非常不均勻，此種情況下插值演算法並不是最好的選擇。
4. 分塊查詢
分塊查詢類似於資料庫中的索引查詢，所以分塊查詢也稱為索引查詢。其演算法的核心還是線性查詢。
現有原始數列 nums=[5,1,9,11,23,16,12,18,24,32,29,25]，需要查詢關鍵字11 是否存在。
第 1 步：使用分塊查詢之前，先要對原始數列按區域分成多個塊。至於分成多少塊，可根據實際情況自行定義。分塊時有一個要求，前一個塊中的最大值必須小於後一個塊的最小值。
塊內部無序，但要保持整個數列
按塊有序。
分塊查詢要求原始數列從整體上具有升序或降序趨勢，如果數列的分佈不具有趨向性，如果仍然想使用分塊查詢，則需要進行分塊有序調整。
第 2 步：根據分塊資訊，建立索引表。索引表至少應該有 2 個欄位，每一塊中的最大值數字以及每一塊的起始地址。顯然索引表中的數字是有序的。
第 3 步：查詢給定關鍵字時，先查詢索引表，查詢關鍵字應該在那個塊中。如查詢關鍵字 29，可知應該在第三塊中，然後根據索引表中所提供的第三塊的地址資訊，再進入第三塊數列，按線性匹配演算法查詢29 具體位置。
編碼實現分塊查詢：
先編碼實現根據分塊數量、建立索引表，這裡使用二維列表儲存儲索引表中的資訊。
'''
分塊：建立索引表
引數：
nums 原始數列
blocks 塊大小
'''
def create_index_table(nums, blocks):
# 索引表使用列表儲存
index_table = []
# 每一塊的數量
n = len(nums) // blocks
for i in range(0, len(nums), n):
# 索引表中的每一行記錄
tmp_lst = []
# 最大值
tmp_lst.append(max(nums[i:i + n-1]))
# 起始地址
tmp_lst.append(i)
# 終止地址
tmp_lst.append(i + n - 1)
# 新增到索引表中
index_table.append(tmp_lst)
return index_table
'''
測試分塊
'''
nums = [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25]
it = create_index_table(nums, 3)
print(it)
'''
輸出結果：
[[11, 0, 3], [23, 4, 7], [32, 8, 11]]
'''
程式碼執行後，輸出結果和分析的結果一樣。
以上程式碼僅對整體趨勢有序的數列進行分塊。如果整體不是趨向有序，則需要提供相應塊排序方案，有興趣者自行完成。
如上程式碼僅為說明分塊查詢演算法。
分塊查詢的完整程式碼：
'''
分塊：建立索引表
引數：
nums 原始數列
blocks 塊大小
'''
def create_index_table(nums, blocks):
# 索引表使用列表儲存
index_table = []
# 每一塊的數量
n = len(nums) // blocks
for i in range(0, len(nums), n):
tmp_lst = []
tmp_lst.append(max(nums[i:i + n - 1]))
tmp_lst.append(i)
tmp_lst.append(i + n - 1)
index_table.append(tmp_lst)
return index_table
'''
使用線性查詢演算法在對應的塊中查詢
'''
def lind_find(nums, start, end):
for i in range(start, end):
if key == nums[i]:
return i
break
return -1
'''
測試分塊
'''
nums = [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25]
key = 16
# 索引表
it = create_index_table(nums, 3)
# 索引表的記錄編號
pos = -1
# 在索引表中查詢
for n in range(len(it) - 1):
# 是不是在第一塊中
if key <= it[0][0]:
pos = 0
# 其它塊中
if it[n][0] < key <= it[n + 1][0]:
pos = n + 1
break
if pos == -1:
print("{0} 在 {1} 數列中不存在".format(key, nums))
else:
idx = lind_find(nums, it[pos][1], it[pos][2] + 1)
if idx != -1:
print("{0} 在 {1} 數列的 {2} 位置".format(key, nums, idx))
else:
print("{0} 在 {1} 數列中不存在".format(key, nums))
'''
輸出結果
16 在 [5, 1, 9, 11, 23, 16, 12, 18, 24, 32, 29, 25] 數列的第 5 位置
'''
分塊查詢對於整體趨向有序的數列，其查詢效能較好。但如果原始數列整體不是有序，則需要提供塊排序演算法，時間複雜度沒有二分查詢演算法好。
分塊查詢需要建立索引表，這也需要額外的儲存空間，其空間複雜度較高。其優於二分的地方在於只需要對原始數列進行部分排序。本質還是以線性查詢為主。
5. 總結
本文講解了線性、二分、插值、分塊查詢演算法。除此之外，還有其它如樹表查詢、雜湊查詢等演算法。
分塊演算法可認為是對線性查詢演算法的優化。
插值查詢可認為是在二分演算法基礎上的一個變化。
演算法沒有固定模式，如果學會了二分查詢演算法，則認為是學會了一招，需要學會領悟，然後再在這一招上演變出更多變化。