前言
概念：二分查詢（Binary Search）演算法，一種針對有序資料集合的查詢演算法，也叫折半查詢演算法。
思想：二分查詢針對的是一個有序的資料集合( 升序或降序 )，查詢思想有點類似分治思想。每次都通過跟區間的中間元素對比，將待查詢的區間縮小為之前的一半，直到找到要查詢的元素，或者區間被縮小為 0
步驟： 定義 low，high，mid指標，分別指向首尾中間 3 個位置，value 是我們要查詢的值
進行如下演算法
（1）當arr[mid] = value 時，找到則返回 mid下標
（2）當arr[mid] < value 時，說明目標元素在經由mid分割的右區間，故將區間起始位置 low 賦值為mid+1
（3）當arr[mid] > value 時，說明目標元素在經由mid分割的左區間，故將區間結束位置 high 賦值為mid-1
圖解：
以有序集合 {8,11,19,23,27,33,45,55,67,98}為例，以查詢值 value = 19進行分析
複雜度分析
假設資料規模是 n，每一輪查詢資料規模都會縮小一半，也就是會除以2。最好的情況就是，在初始化就找到，最壞情況下，直到查詢區間被縮小為空，才停止。
查詢的區間變化是 —— \(n\)、\(\frac{n}{2}\)、\(\frac{n}{4}\)、\(\frac{n}{8}\)、... 、\(\frac{n}{2^k}\), 可以看出來，這是一個等比數列。其中 \(\frac{n}{2^k}\) = \(1\) 時， k 的值就是總共縮小的次數。而每一次縮小操作只涉及兩個資料的大小比較，所以，經過了 k 次區間縮小操作，時間複雜度就是 O(k)。通過 \(\frac{n}{2^k}\) = \(1\) ，我們可以求得 \(k\) = \(\log_2n\)，所以時間複雜度就是 O(logn)
優點：高效的二分查詢，擁有驚人的查詢速度，因為 logn 是一個非常“恐怖”的數量級，即便 n 非常非常大，對應的 logn 也很小。比如 n 等於 2 的 32 次方，這個數很大了吧？大約是 42 億。也就是說，如果我們在 42 億個資料中用二分查詢一個資料，最多需要比較 32 次
編碼
常規
迭代法實現
/**
* 迭代法實現
* @param arr
* @param value
* @return
*/
public static int binarySerach1(int[] arr, int value) {
//頭部指標
int low = 0;
//尾部指標
int high = arr.length - 1;
while (low <= high){
int mid = low + ((high - low) >> 1);
if (arr[mid] == value){
return mid;
}else if (arr[mid] > value){
high = mid - 1;
}else {
low = mid + 1;
}
}
return -1;
}
注意點：
-
迴圈退出條件：注意是 low <= high，而不是 low < high
-
mid 的取值問題：
-
mid =( low + high)/2這種寫法是有問題的。因為如果 low 和 high 比較大的話，兩者之和就有可能會溢位 -
改進的方法是將 mid 的計算方式寫成
low + (high - low)/2 -
將除法運算改為位運算，因為相比除法運算來說，計算機處理位運算要快得多
-
遞迴法實現
/**
* 遞迴法
* @param arr
* @param value
* @return
*/
public static int binarySerach2(int[] arr, int value){
return bsearch(arr,0,arr.length -1,value);
}
private static int bsearch(int[] arr, int low, int high, int value) {
if (low > high) return -1;
int mid = low + ((high - low) >> 1);
if (arr[mid] == value) {
return mid;
} else if (arr[mid] > value) {
return bsearch(arr, low, mid-1, value);
} else {
return bsearch(arr, mid+1, high, value);
}
}
變種
1、查詢第一個值等於給定值的元素
上面實現的二分查詢演算法實比較簡單的需求，是有一定侷限性的，例如，它是預設元素是不重複的。那麼，假設有序結合是存在重複元素的，那麼用上面的演算法來解決肯定是有問題的。以有序陣列{1,3,4,5,6,8,8,8,11,18}，其中，a[5]，a[6]，a[7] 的值都等於 8，是重複的資料。我們希望查詢第一個等於 8 的資料，也就是下標是 5 的元素。配圖如下：
編碼：
public static int binarySerach3(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = low + ((high - low) >> 1);
if (arr[mid] > value) {
high = mid - 1;
} else if (arr[mid] < value) {
low = mid + 1;
} else {
if ((mid == 0) || (arr[mid - 1] != value)) return mid;
else high = mid - 1;
}
}
return -1;
}
重點：從第11行程式碼才是演算法的重點，前面的程式碼和之前的思路是一樣的，在第11行程式碼開始就不同了，我們的需求是查詢第一個值等於給定值的元素，那麼只要注意兩個地方就可以了
mid == 0，這說明找到的值是陣列下標 0 位置的值，也就是起點位置，那麼肯定就是第一個值了- 如果
mid前一位的值不是要匹配的value，那麼說明找到的就是第一個值，否則，high指向mid - 1，重新比較
2、查詢最後一個值等於給定值的元素
還是以有序陣列{1,3,4,5,6,8,8,8,11,18}，其中，a[5]，a[6]，a[7] 的值都等於 8，是重複的資料。我們希望查詢最後個等於 8 的資料，也就是下標是 7 的元素。
編碼：
/**
* 查詢最後一個值等於給定值的元素
* @param arr
* @param value
* @return
*/
public static int binarySerach4(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = low + ((high - low) >> 1);
if (arr[mid] > value) {
high = mid - 1;
} else if (arr[mid] < value) {
low = mid + 1;
} else {
if ((mid == arr.length - 1) || (arr[mid + 1] != value)) return mid;
else high = mid + 1;
}
}
return -1;
}
這個變種的案例與第一個很相似，稍微修改一下第11行後邊的程式碼條件即可，不做詳細分析
3、查詢第一個大於等於給定值的元素
我們再來看另外一類變形問題。在有序陣列中，查詢第一個大於等於給定值的元素。比如，陣列中儲存的這樣一個序列：{3，4，6，7，10}，如果查詢第一個大於等於 5 的元素，那就是 6。
編碼：
/**
* 變種三: 查詢第一個大於等於給定值的元素
* @param arr
* @param value
* @return
*/
public static int binarySerach3(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = low + ((high - low) >> 1);
if (arr[mid] >= value) {
if ((mid == 0) || (arr[mid - 1] < value)) return mid;
else high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}
重點：該變種也是尋找的第一個的值，同變種一的查詢邏輯是一樣的，只是將匹配值value改成查詢比比值value大的,將arr[mid] >= value統一處理
4、查詢最後一個小於等於給定值的元素
仍然以有效序列{3，4，6，7，10}為例，查詢最後一個小於等於給定值的元素，如果給定值是5，那查詢處理的就是就是 4。
/**
* 變種四: 查詢第一個大於等於給定值的元素
* @param arr
* @param value
* @return
*/
public static int binarySerach4(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = low + ((high - low) >> 1);
if (arr[mid] > value) {
high = mid - 1;
} else {
if ((mid == arr.length - 1) || (arr[mid + 1] > value)) return mid;
else low = mid + 1;
}
}
return -1;
}
思路和上面的大致一樣，就不作分析了
侷限性
二分查詢的時間複雜度是 O(logn)，查詢資料的效率非常高。不過，並不是什麼情況下都可以用二分查詢，它的應用場景是有很大侷限性的。那什麼情況下適合用二分查詢，什麼情況下不適合呢？
1、二分查詢依賴的是順序表結構，簡單點說就是陣列
那二分查詢能否依賴其他資料結構呢？比如連結串列。答案是不可以的，主要原因是二分查詢演算法需要按照下標隨機訪問元素。我們在陣列和連結串列那兩節講過，陣列按照下標隨機訪問資料的時間複雜度是 O(1)，而連結串列隨機訪問的時間複雜度是 O(n)。所以，如果資料使用連結串列儲存，二分查詢的時間複雜就會變得很高。
2、二分查詢針對的是有序資料
二分查詢對這一點的要求比較苛刻，資料必須是有序的。如果資料沒有序，我們需要先排序。排序的時間複雜度最低是 O(nlogn)。所以，如果我們針對的是一組靜態的資料，沒有頻繁地插入、刪除，我們可以進行一次排序，多次二分查詢。這樣排序的成本可被均攤，二分查詢的邊際成本就會比較低。
所以，二分查詢只能用在插入、刪除操作不頻繁，一次排序多次查詢的場景中。針對動態變化的資料集合，二分查詢將不再適用。
3、資料量太小不適合二分查詢。
如果要處理的資料量很小，完全沒有必要用二分查詢，順序遍歷就足夠了。比如我們在一個大小為 10 的陣列中查詢一個元素，不管用二分查詢還是順序遍歷，查詢速度都差不多。只有資料量比較大的時候，二分查詢的優勢才會比較明顯。
不過，這裡有一個例外。如果資料之間的比較操作非常耗時，不管資料量大小，我都推薦使用二分查詢。比如，陣列中儲存的都是長度超過 300 的字串，如此長的兩個字串之間比對大小，就會非常耗時。我們需要儘可能地減少比較次數，而比較次數的減少會大大提高效能，這個時候二分查詢就比順序遍歷更有優勢。
4、資料量太大也不適合二分查詢。
二分查詢的底層需要依賴陣列這種資料結構，而陣列為了支援隨機訪問的特性，要求記憶體空間連續，對記憶體的要求比較苛刻。比如，我們有 1GB 大小的資料，如果希望用陣列來儲存，那就需要 1GB 的連續記憶體空間。
注意這裡的“連續”二字，也就是說，即便有 2GB 的記憶體空間剩餘，但是如果這剩餘的 2GB 記憶體空間都是零散的，沒有連續的 1GB 大小的記憶體空間，那照樣無法申請一個 1GB 大小的陣列。而我們的二分查詢是作用在陣列這種資料結構之上的，所以太大的資料用陣列儲存就比較吃力了，也就不能用二分查詢了。
宣告
參考資料：王爭 —《資料結構與演算法之美》 、 排序的最低時間複雜度為什麼是O（nlogn）
文章為原創，歡迎轉載，註明出處即可
個人能力有限，有不正確的地方，還請指正
本文的程式碼已上傳github,歡迎star —— GitHub地址