本文轉自labuladong的算法小抄 ， 代碼部分我使用go重新描述
先給大家講個笑話樂呵一下：
有一天阿東到圖書館借了 N 本書，出圖書館的時候，警報響了，於是保安把阿東攔下，要檢查一下哪本書沒有登記出借。阿東正准備把每一本書在報警器下過一下，以找出引發警報的書，但是保安露出不屑的眼神：你連二分查找都不會嗎？於是保安把書分成兩堆，讓第一堆過一下報警器，報警器響；於是再把這堆書分成兩堆…… 最終，檢測了 logN 次之后，保安成功的找到了那本引起警報的書，露出了得意和嘲諷的笑容。於是阿東背着剩下的書走了。
從此，圖書館丟了 N - 1 本書。
二分查找並不簡單，Knuth 大佬（發明 KMP 算法的那位）都說二分查找：思路很簡單，細節是魔鬼。很多人喜歡拿整型溢出的 bug 說事兒，但是二分查找真正的坑根本就不是那個細節問題，而是在於到底要給 mid 加一還是減一，while 里到底用 <= 還是 <。
你要是沒有正確理解這些細節，寫二分肯定就是玄學編程，有沒有 bug 只能靠菩薩保佑。我特意寫了一首詩來歌頌該算法，概括本文的主要內容，建議保存：
本文就來探究幾個最常用的二分查找場景：尋找一個數、尋找左側邊界、尋找右側邊界。而且，我們就是要深入細節，比如不等號是否應該帶等號，mid 是否應該加一等等。分析這些細節的差異以及出現這些差異的原因，保證你能靈活准確地寫出正確的二分查找算法。
零、二分查找框架
func binarySearch(nums []int, target int)int { left := 0, right := ... for ... { 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 寫清楚，這樣可以清楚地展現所有細節。本文都會使用 else if，旨在講清楚，讀者理解后可自行簡化。
其中 ... 標記的部分，就是可能出現細節問題的地方，當你見到一個二分查找的代碼時，首先注意這幾個地方。后文用實例分析這些地方能有什么樣的變化。
另外聲明一下，計算 mid 時需要防止溢出，代碼中 left + (right - left) / 2 就和 (left + right) / 2 的結果相同，但是有效防止了 left 和 right 太大直接相加導致溢出。
一、尋找一個數（基本的二分搜索）
這個場景是最簡單的，可能也是大家最熟悉的，即搜索一個數，如果存在，返回其索引，否則返回 -1。
func binarySearch(nums []int, target int) int { left := 0 right := len(nums) - 1 //注意 for left <= right { //注意 mid := left + (right-left)/2 if nums[mid] == target { return mid } else if nums[mid] < target { left = mid + 1 //注意 } else if nums[mid] > target { right = mid - 1 //注意 } } return -1 }
1、為什么 for循環的條件中是 <=，而不是 <？
答：因為初始化 right 的賦值是 nums.length - 1，即最后一個元素的索引，而不是 nums.length。
這二者可能出現在不同功能的二分查找中，區別是：前者相當於兩端都閉區間 [left, right]，后者相當於左閉右開區間 [left, right)，因為索引大小為 nums.length 是越界的。
我們這個算法中使用的是前者 [left, right] 兩端都閉的區間。這個區間其實就是每次進行搜索的區間。
什么時候應該停止搜索呢？當然，找到了目標值的時候可以終止：
if nums[mid] == target { return mid }
但如果沒找到，就需要 for 循環終止，然后返回 -1。那 for 循環什么時候應該終止？搜索區間為空的時候應該終止，意味着你沒得找了，就等於沒找到嘛。
for left <= right 的終止條件是 left == right + 1，寫成區間的形式就是 [right + 1, right]，或者帶個具體的數字進去 [3, 2]，可見這時候區間為空，因為沒有數字既大於等於 3 又小於等於 2 的吧。所以這時候 for 循環終止是正確的，直接返回 -1 即可。
for left < right 的終止條件是 left == right，寫成區間的形式就是 [right, right]，或者帶個具體的數字進去 [2, 2]，這時候區間非空，還有一個數 2，但此時 for 循環終止了。也就是說這區間 [2, 2] 被漏掉了，索引 2 沒有被搜索，如果這時候直接返回 -1 就是錯誤的。
當然，如果你非要用 for left < right 也可以，我們已經知道了出錯的原因，就打個補丁好了：
//... for 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，然后向左或向右線性搜索不行嗎？可以，但是不好，因為這樣難以保證二分查找對數級的復雜度了。
我們后續的算法就來討論這兩種二分查找的算法。
二、尋找左側邊界的二分搜索
以下是最常見的代碼形式，其中的標記是需要注意的細節：
func LeftBound(nums []int, target int) int { if len(nums) == 0 { return -1 } left := 0 right := len(nums) //注意 for left < right { //注意 mid := left + (right-left)/2 if nums[mid] == target { right = mid } else if nums[mid] < target { left = mid + 1 } else if nums[mid] > target { right = mid //注意 } } return left }
1、為什么 for 中是 < 而不是 <=?
答：用相同的方法分析，因為 right = len(nums) 而不是 len(nums) - 1。因此每次循環的「搜索區間」是 [left, right) 左閉右開。
for left < right 終止的條件是 left == right，此時搜索區間 [left, left) 為空，所以可以正確終止。
PS：這里先要說一個搜索左右邊界和上面這個算法的一個區別，也是很多讀者問的：剛才的 right 不是 len(nums) - 1 嗎，為啥這里非要寫成 len(nums) 使得「搜索區間」變成左閉右開呢？
因為對於搜索左右側邊界的二分查找，這種寫法比較普遍，我就拿這種寫法舉例了，保證你以后遇到這類代碼可以理解。你非要用兩端都閉的寫法反而更簡單，我會在后面寫相關的代碼，把三種二分搜索都用一種兩端都閉的寫法統一起來，你耐心往后看就行了。
2、為什么沒有返回 -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：
if left == len(nums) || nums[left] != target { return -1 } return left
3、為什么 left = mid + 1，right = mid ？和之前的算法不一樣？
答：這個很好解釋，因為我們的「搜索區間」是 [left, right) 左閉右開，所以當 nums[mid] 被檢測之后，下一步的搜索區間應該去掉 mid 分割成兩個區間，即 [left, mid) 或 [mid + 1, right)。
4、為什么該算法能夠搜索左側邊界？
答：關鍵在於對於 nums[mid] == target 這種情況的處理：
if nums[mid] == target { right = mid }
可見，找到 target 時不要立即返回，而是縮小「搜索區間」的上界 right，在區間 [left, mid) 中繼續搜索，即不斷向左收縮，達到鎖定左側邊界的目的。
5、為什么返回 left 而不是 right？
答：都是一樣的，因為 for終止的條件是 left == right。
6、能不能想辦法把 right 變成 len(nums) - 1，也就是繼續使用兩邊都閉的「搜索區間」？這樣就可以和第一種二分搜索在某種程度上統一起來了。
答：當然可以，只要你明白了「搜索區間」這個概念，就能有效避免漏掉元素，隨便你怎么改都行。下面我們嚴格根據邏輯來修改：
因為你非要讓搜索區間兩端都閉，所以 right 應該初始化為 len(nums) - 1，for 的終止條件應該是 left == right + 1，也就是其中應該用 <=：
func LeftBound2(nums []int, target int) int { left := 0 right := len(nums) - 1 //注意 for left <= right { //注意 mid := left + (right-left)/2 //if else } return -1 }
因為搜索區間是兩端都閉的，且現在是搜索左側邊界，所以 left 和 right 的更新邏輯如下：
if nums[mid] == target { //收縮右側邊界 right = mid - 1 } else if nums[mid] < target { //搜索區間變為 [mid+1, right] left = mid + 1 //注意 } else if nums[mid] > target { //搜索區間變為 [left, mid-1] right = mid - 1 }
由於 for的退出條件是 left == right + 1，所以當 target 比 nums 中所有元素都大時，會存在以下情況使得索引越界：
if left >= len(nums) || nums[left] != target { return -1 }
至此，整個算法就寫完了，完整代碼如下：
func LeftBound2(nums []int, target int) int { left := 0 right := len(nums) - 1 //注意 for left <= right { //注意 mid := left + (right-left)/2 if nums[mid] == target { //收縮右側邊界 right = mid - 1 } else if nums[mid] < target { //搜索區間變為 [mid+1, right] left = mid + 1 //注意 } else if nums[mid] > target { //搜索區間變為 [left, mid-1] right = mid - 1 } } if left >= len(nums) || nums[left] != target { return -1 } return left }
這樣就和第一種二分搜索算法統一了，都是兩端都閉的「搜索區間」，而且最后返回的也是 left 變量的值。只要把住二分搜索的邏輯，兩種形式大家看自己喜歡哪種記哪種吧。
三、尋找右側邊界的二分查找
類似尋找左側邊界的算法，這里也會提供兩種寫法，還是先寫常見的左閉右開的寫法，只有兩處和搜索左側邊界不同，已標注：
func RightBound(nums []int, target int) int { left := 0 right := len(nums) - 1 //注意 for left <= right { //注意 mid := left + (right-left)/2 if nums[mid] == target { //收縮左側邊界 left = mid + 1 } else if nums[mid] < target { //搜索區間變為 [mid+1, right] left = mid + 1 //注意 } else if nums[mid] > target { //搜索區間變為 [left, mid-1] right = mid - 1 } }
if right < 0 || nums[right] != target {
return -1
}
return right
return right }
1、為什么這個算法能夠找到右側邊界？
答：類似地，關鍵點還是這里：
if nums[mid] == target { //收縮左側邊界 left = mid + 1 }
當 nums[mid] == target 時，不要立即返回，而是增大「搜索區間」的下界 left，使得區間不斷向右收縮，達到鎖定右側邊界的目的。
當 target 比所有元素都小時，right 會被減到 -1，所以需要在最后防止越界：
