int binarySearch(int[] nums, int target) {
int left = 0, right = ...;
while (...) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
...
}else if (nums[mid] < target) {
left = ...
}else if (nums[mid] > target) {
right = ...
}
}
return ...
}
分析二分查找的一個技巧是：不要出現 else，而是把所有情況用 else if 寫清楚，這樣可以清楚地展現所有細節
其中 … 標記的部分，就是可能出現細節問題的地方，當你見到一個二分查找的代碼時，首先注意這幾個地方
另外聲明一下，計算 mid 時需要防止溢出，代碼中 left + (right - left) / 2 就和 (left + right) / 2 的結果相同，但是有效防止了 left 和 right 太大直接相加導致溢出。
尋找一個數(基本的二分搜索)
int binarySearch(int[] nums, int target) {
int left = 0;
int right = nums.length - 1; // 注意 1
while (left <= right) { // 注意 2
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
}else if (nums[mid] < target) {
left = mid + 1; // 注意 3
}else if (nums[mid] > target) {
right = mid - 1; // 注意 4
}
}
return -1;
}
1. 爲什麼while循環的條件中是<=, 而不是< ?
因爲初始化right的賦值是nums.length - 1, 即最後一個元素的索引,而不是 nums.length。
這二者可能出現在不同功能的二分查找中，區別是：前者相當於兩端都閉區間 [left, right]，後者相當於左閉右開區間 [left, right)，因爲索引大小爲 nums.length 是越界的。
我們這個算法中使用的是前者 [left, right] 兩端都閉的區間。這個區間其實就是每次進行搜索的區間
什麼時候應該停止搜索呢？當然，找到了目標值的時候可以終止：
if(nums[mid] == target)
return mid;
但如果沒找到，就需要 while 循環終止，然後返回 -1。那 while 循環什麼時候應該終止？搜索區間爲空的時候應該終止，意味着你沒得找了，就等於沒找到嘛。
while(left <= right) 的終止條件是 left == right + 1，寫成區間的形式就是 [right + 1, right]，或者帶個具體的數字進去 [3, 2]，可見這時候區間爲空，因爲沒有數字既大於等於 3 又小於等於 2 的吧。所以這時候 while 循環終止是正確的，直接返回 -1 即可
while(left < right) 的終止條件是 left == right，寫成區間的形式就是 [left, right]，或者帶個具體的數字進去 [2, 2]，這時候區間非空，還有一個數 2，但此時 while 循環終止了。也就是說這區間 [2, 2] 被漏掉了，索引 2 沒有被搜索，如果這時候直接返回 -1 就是錯誤的。
例如數組nums = [1, 2, 3, 4, 5], 尋找target = 5,
如果用while (left < right) 第一次mid = (0 + 4) / 2 = 2
nums[2] == 3 < target 推出 left = mid + 1 = 3, right = 4, left < right; mid = (3 + 4) / 2 = 3,
nums[3] == 4 < target, 推出 left = mid + 1 = 4, right = 4 此時left 是與right相等的, 由於while (left < right) 所以退出了while循環,未找到target,其實是漏掉了[5, 5]這個區間的數
當然，如果你非要用 while(left < right) 也可以，我們已經知道了出錯的原因，就打個補丁好了：
//…
while(left < right) {
// …
}
return nums[left] == target ? left : -1;
2. 爲什麼 left = mid + 1, right = mid - 1 ? 我看有的代碼是 right = mid 或者 left = mid，沒有這些加加減減，到底怎麼回事，怎麼判斷？
這也是二分查找的一個難點
剛纔明確了「搜索區間」這個概念，而且本算法的搜索區間是兩端都閉的，即 [left, right]。那麼當我們發現索引 mid 不是要找的 target 時，下一步應該去搜索哪裏呢？
當然是去搜索 [left, mid-1] 或者 [mid+1, right] 對不對？因爲 mid 已經搜索過，應該從搜索區間中去除。
3. 此算法有什麼缺陷？
比如說給你有序數組 nums = [1,2,2,2,3]，target 爲 2，此算法返回的索引是 2，沒錯。但是如果我想得到 target 的左側邊界，即索引 1，或者我想得到 target 的右側邊界，即索引 3，這樣的話此算法是無法處理的。
這樣的需求很常見，你也許會說，找到一個 target，然後向左或向右線性搜索不行嗎？可以，但是不好，因爲這樣難以保證二分查找對數級的複雜度了。
總結一 :
搜索一個元素時, 搜索區間兩端閉
while條件帶等號, 否則需要打補丁
if相等就返回,其他的事崩操心
mid必須加減1, 因爲區間兩端閉
while結束就涼了, 悽悽慘慘返-1
尋找左側邊界的二分搜索
以下是最常見的代碼形式，其中的標記是需要注意的細節：
nums = [1,2,2,2,3]，target 爲 2 得到 target 的左側邊界，即索引 1
int left_bound(int[] nums, int target) {
int (nums.length == 0) return -1;
int left = 0;
int right = nums.lengh; // 注意 1
while (left < right) { // 注意 2
int mid = (left + right) / 2;
if (nums[mid] == target) {
right = mid;
}else if (nums[mid] < target) {
left = mid + 1;
}else if (nums[mid] > target) {
right = mid; // 注意 3
}
}
return left;
}
1 爲什麼 while 中是 < 而不是 <=?
用相同的方法分析，因爲 right = nums.length 而不是 nums.length - 1。因此每次循環的「搜索區間」是 [left, right) 左閉右開
while(left < right) 終止的條件是 left == right，此時搜索區間 [left, left) 爲空，所以可以正確終止。
2 這裏先要說一個搜索左右邊界和上面這個算法的一個區別，也是很多讀者問的：剛纔的 right 不是 nums.length - 1 嗎，爲啥這裏非要寫成 nums.length 使得「搜索區間」變成左閉右開呢？
因爲對於搜索左右側邊界的二分查找，這種寫法比較普遍，我就拿這種寫法舉例了，保證你以後遇到這類代碼可以理解。你非要用兩端都閉的寫法反而更簡單，我會在後面寫相關的代碼，把三種二分搜索都用一種兩端都閉的寫法統一起來，你耐心往後看就行了。
3 爲什麼沒有返回 -1 的操作？如果 nums 中不存在 target 這個值，怎麼辦？
理解下[左側邊界]的特殊含義
對於這個數組，算法會返回 1。這個 1 的含義可以這樣解讀：nums 中小於 2 的元素有 1 個。
比如對於有序數組 nums = [2,3,5,7], target = 1，算法會返回 0，含義是：nums 中小於 1 的元素有 0 個
再比如說 nums = [2,3,5,7], target = 8，算法會返回 4，含義是：nums 中小於 8 的元素有 4 個
綜上可以看出，函數的返回值（即 left 變量的值）取值區間是閉區間 [0, nums.length]，所以我們簡單添加兩行代碼就能在正確的時候 return -1：
while (left < right) {
//...
}
// target 比所有數都大
if (left == nums.length) return -1;
// 類似之前算法的處理方式 target 比所有數 都小返回 -1, 否則 返回 left
return nums[left] == target ? left : -1;
4 爲什麼 left = mid + 1，right = mid ？和之前的算法不一樣？
這個很好解釋，因爲我們的「搜索區間」是 [left, right) 左閉右開，所以當 nums[mid] 被檢測之後，下一步的搜索區間應該去掉 mid 分割成兩個區間，即 [left, mid) 或 [mid + 1, right)。
5 爲什麼該算法能夠搜索左側邊界？
關鍵在於對於 nums[mid] == target 這種情況的處理
if (nums[mid] == target)
right = mid;
可見，找到 target 時不要立即返回，而是縮小「搜索區間」的上界 right，在區間 [left, mid) 中繼續搜索，即不斷向左收縮，達到鎖定左側邊界的目的。
6 爲什麼返回 left 而不是 right？
都是一樣的，因爲 while 終止的條件是 left == right。
7 能不能想辦法把 right 變成 nums.length - 1，也就是繼續使用兩邊都閉的「搜索區間」？這樣就可以和第一種二分搜索在某種程度上統一起來了。
當然可以，只要你明白了「搜索區間」這個概念，就能有效避免漏掉元素，隨便你怎麼改都行。下面我們嚴格根據邏輯來修改：
因爲你非要讓搜索區間兩端都閉，所以 right 應該初始化爲 nums.length - 1，while 的終止條件應該是 left == right + 1，也就是其中應該用 <=
int left_bound(int[] nums, int target) {
// 搜索區間爲 [left, right]
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
// 搜索區間變爲[mid + 1, right]
left = mid + 1;
}else if (nums[mid] > target) {
// 搜索區間變爲[left, mid - 1]
right = mid - 1;
}else if (nums[mid] == target) {
// 收縮右側邊界
right = mid - 1;
}
}
由於 while 的退出條件是 left == right + 1，所以當 target 比 nums 中所有元素都大時，會存在以下情況使得索引越界
因此，最後返回結果的代碼應該檢查越界情況：
if (left >= nums.length || nums[left] != target)
return -1;
return left;
完整代碼如下
int left_bound(int[] nums, int target) {
int left = 0, right = nums.length - 1;
// 搜索區間爲 [left, right]
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
// 搜索區間變爲 [mid+1, right]
left = mid + 1;
} else if (nums[mid] > target) {
// 搜索區間變爲 [left, mid-1]
right = mid - 1;
} else if (nums[mid] == target) {
// 收縮右側邊界
right = mid - 1;
}
}
// 檢查出界情況
if (left >= nums.length || nums[left] != target)
return -1;
return left;
}
這樣就和第一種二分搜索算法統一了，都是兩端都閉的「搜索區間」，而且最後返回的也是 left 變量的值。只要把住二分搜索的邏輯，兩種形式大家看自己喜歡哪種記哪種吧
尋找右側邊界的二分搜索
類似尋找左側邊界的算法，這裏也會提供兩種寫法，還是先寫常見的左閉右開的寫法，只有兩處和搜索左側邊界不同，已標註：
int right_bound(int[] nums, int target) {
if (nums.length == 0) return -1;
int left = 0, right = nums.length;
while (left < right) {
int mid = (left + right) / 2;
if (nums[mid] == target) {
left = mid + 1; // 注意
} else if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid;
}
}
return left - 1; // 注意
}
1 爲什麼這個算法能夠找到右側邊界？
關鍵點在於
if (nums[mid] == target) {
left = mid + 1;
當 nums[mid] == target 時，不要立即返回，而是增大「搜索區間」的下界 left，使得區間不斷向右收縮，達到鎖定右側邊界的目的。
2 爲什麼最後返回 left - 1 而不像左側邊界的函數，返回 left？而且我覺得這裏既然是搜索右側邊界，應該返回 right 纔對。
首先，while 循環的終止條件是 left == right，所以 left 和 right 是一樣的，你非要體現右側的特點，返回 right - 1 好了。
至於爲什麼要減一，這是搜索右側邊界的一個特殊點，關鍵在這個條件判斷：
if (nums[mid] == target) {
left = mid + 1;
// 這樣想: mid = left - 1
因爲我們對 left 的更新必須是 left = mid + 1，就是說 while 循環結束時，nums[left] 一定不等於 target 了，而 nums[left-1] 可能是 target。
3 爲什麼沒有返回 -1 的操作？如果 nums 中不存在 target 這個值，怎麼辦？
類似之前的左側邊界搜索，因爲 while 的終止條件是 left == right，就是說 left 的取值範圍是 [0, nums.length]，所以可以添加兩行代碼，正確地返回 -1：
while (left < right) {
// ...
}
if (left == 0) return -1;
return nums[left-1] == target ? (left-1) : -1;
4 是否也可以把這個算法的「搜索區間」也統一成兩端都閉的形式呢？這樣這三個寫法就完全統一了，以後就可以閉着眼睛寫出來了。
int right_bound(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
// 這裏改成收縮左側邊界即可
left = mid + 1;
}else if (nums[mid] > target) {
right = mid - 1;
}else if (nums[mid] < target) {
left = mid + 1;
}
}
// 這裏改爲檢查 right 越界的情況，見下圖
if (right < 0 || nums[right] != target)
return -1;
return right;
}
當 target 比所有元素都小時，right 會被減到 -1，所以需要在最後防止越界：
此，搜索右側邊界的二分查找的兩種寫法也完成了，其實將「搜索區間」統一成兩端都閉反而更容易記憶，你說是吧？
總結 邏輯統一
來梳理一下這些細節差異的因果邏輯：
第一個，最基本的二分查找算法：
因爲我們初始化 right = nums.length - 1
所以決定了我們的「搜索區間」是 [left, right]
所以決定了 while (left <= right)
同時也決定了 left = mid+1 和 right = mid-1
因爲我們只需找到一個 target 的索引即可
所以當 nums[mid] == target 時可以立即返回
第一個，尋找左側邊界的二分查找：
因爲我們初始化 right = nums.length
所以決定了我們的「搜索區間」是 [left, right)
所以決定了 while (left < right)
同時也決定了 left = mid + 1 和 right = mid
因爲我們需找到 target 的最左側索引
所以當 nums[mid] == target 時不要立即返回
而要收緊右側邊界以鎖定左側邊界
第三個，尋找右側邊界的二分查找：
因爲我們初始化 right = nums.length
所以決定了我們的「搜索區間」是 [left, right)
所以決定了 while (left < right)
同時也決定了 left = mid + 1 和 right = mid
因爲我們需找到 target 的最右側索引
所以當 nums[mid] == target 時不要立即返回
而要收緊左側邊界以鎖定右側邊界
又因爲收緊左側邊界時必須 left = mid + 1
所以最後無論返回 left 還是 right，必須減一
對於尋找左右邊界的二分搜索，常見的手法是使用左閉右開的「搜索區間」，我們還根據邏輯將「搜索區間」全都統一成了兩端都閉，便於記憶，只要修改兩處即可變化出三種寫法：
int binary_search(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while(left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid - 1;
} else if(nums[mid] == target) {
// 直接返回
return mid;
}
}
// 直接返回
return -1;
}
int left_bound(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] == target) {
// 別返回，鎖定左側邊界
right = mid - 1;
}
}
// 最後要檢查 left 越界的情況
if (left >= nums.length || nums[left] != target)
return -1;
return left;
}
int right_bound(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid - 1;
} else if (nums[mid] == target) {
// 別返回，鎖定右側邊界
left = mid + 1;
}
}
// 最後要檢查 right 越界的情況
if (right < 0 || nums[right] != target)
return -1;
return right;
}
1、分析二分查找代碼時，不要出現 else，全部展開成 else if 方便理解。
2、注意「搜索區間」和 while 的終止條件，如果存在漏掉的元素，記得在最後檢查。
3、如需定義左閉右開的「搜索區間」搜索左右邊界，只要在 nums[mid] == target 時做修改即可，搜索右側時需要減一。
4、如果將「搜索區間」全都統一成兩端都閉，好記，只要稍改 nums[mid] == target 條件處的代碼和返回的邏輯即可，推薦拿小本本記下，作爲二分搜索模板。