本文轉自labuladong的演算法小抄 ， 程式碼部分我使用go重新描述

先給大家講個笑話樂呵一下：

有一天阿東到圖書館借了 N 本書，出圖書館的時候，警報響了，於是保安把阿東攔下，要檢查一下哪本書沒有登記出借。阿東正準備把每一本書在報警器下過一下，以找出引發警報的書，但是保安露出不屑的眼神：你連二分查詢都不會嗎？於是保安把書分成兩堆，讓第一堆過一下報警器，報警器響；於是再把這堆書分成兩堆…… 最終，檢測了 logN 次之後，保安成功的找到了那本引起警報的書，露出了得意和嘲諷的笑容。於是阿東揹著剩下的書走了。

從此，圖書館丟了 N - 1 本書。

二分查詢並不簡單，Knuth 大佬（發明 KMP 演算法的那位）都說二分查詢：思路很簡單，細節是魔鬼

你要是沒有正確理解這些細節，寫二分肯定就是玄學程式設計，有沒有 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，所以需要在最後防止越界：