數據結構和算法面試題系列—二分查找算法詳解

這個系列是我多年前找工做時對數據結構和算法總結，其中有基礎部分，也有各大公司的經典的面試題，最先發布在CSDN。現整理爲一個系列給須要的朋友參考，若有錯誤，歡迎指正。本系列完整代碼地址在 這裏。

0 概述

二分查找自己是個簡單的算法，可是正是由於其簡單，更容易寫錯。甚至於在二分查找算法剛出現的時候，也是存在bug的（溢出的bug），這個bug直到幾十年後才修復（見《編程珠璣》）。本文打算對二分查找算法進行總結，並對由二分查找引伸出來的問題進行分析和彙總。如有錯誤，請指正。本文完整代碼在 這裏 。

1 二分查找基礎

相信你們都知道二分查找的基本算法，以下所示，這就是二分查找算法代碼：

/**
 * 基本二分查找算法
 */
int binarySearch(int a[], int n, int t)
{
    int l = 0, u = n - 1;
    while (l <= u) {
        int m = l + (u - l) / 2; // 同（l+u）/ 2，這裏是爲了防溢出
        if (t > a[m])
            l = m + 1;
        else if (t < a[m])
            u = m - 1;
        else
            return m;
    }
    return -(l+1);
}
複製代碼

算法的思想就是：從數組中間開始，每次排除一半的數據，時間複雜度爲O(lgN)。這依賴於數組有序這個性質。若是t存在數組中，則返回t在數組的位置；不然，不存在則返回-(l+1)。

這裏須要解釋下爲何t不存在數組中時不是返回-1而要返回-(l+1)。首先咱們能夠觀察 l 的值，若是查找不成功，則 l 的值剛好是 t 應該在數組中插入的位置。

舉個例子，假定有序數組a={1, 3, 4, 7, 8}， 那麼若是t=0，則顯然t不在數組中，則二分查找算法最終會使得l=0 > u=-1退出循環；若是t=9，則t也不在數組中，則最後l=5 > u=4退出循環。若是t=5，則最後l=3 > u=2退出循環。所以在一些算法中，好比DHT（一致性哈希）中，就須要這個返回值來使得新加入的節點能夠插入到合適的位置中，在求最長遞增子序列的NlgN算法中，也用到了這一點，參見博文最長遞增子序列算法。

還有一個小點就是之因此返回-(l+1)而不是直接返回 -l 是由於 l 可能爲0，若是直接返回 -l 就沒法判斷是正常返回位置0仍是查找不成功返回的0。

2 查找有序數組中數字第一次出現位置

如今考慮一個稍微複雜點的問題，若是有序數組中有重複數字，好比數組a={1, 2, 3, 3, 5, 7, 8}，須要在其中找出3第一次出現的位置。這裏3第一次出現位置爲2。這個問題在《編程珠璣》第九章有很好的分析，這裏就直接用了。算法的精髓在於循環不變式的巧妙設計，代碼以下：

/**
 * 二分查找第一次出現位置
 */
int binarySearchFirst(int a[], int n, int t)
{
    int l = -1, u = n;
    while (l + 1 != u) {
        /*循環不變式a[l]<t<=a[u] && l<u*/
        int m = l + (u - l) / 2; //同（l+u）/ 2
        if (t > a[m])
            l = m;
        else
            u = m;
    }
    /*assert: l+1=u && a[l]<t<=a[u]*/
    int p = u;
    if (p>=n || a[p]!=t)
        p = -1;
    return p;
}
複製代碼

算法分析：設定兩個不存在的元素a[-1]和a[n]，使得a[-1] < t <= a[n]，可是咱們並不會去訪問這兩個元素，由於(l+u)/2 > l=-1, (l+u)/2 < u=n。循環不變式爲l<u && t>a[l] && t<=a[u] 。循環退出時必然有l+1=u, 並且a[l] < t <= a[u]。循環退出後u的值爲t可能出現的位置，其範圍爲[0, n]，若是t在數組中，則第一個出現的位置p=u，若是不在，則設置p=-1返回。該算法的效率雖然解決了更爲複雜的問題，可是其效率比初始版本的二分查找還要高，由於它在每次循環中只須要比較一次，前一程序則一般須要比較兩次。

舉個例子：對於數組a={1, 2, 3, 3, 5, 7, 8}，咱們若是查找t=3，則能夠獲得p=u=2，若是查找t=4，a[3]<t<=a[4]， 因此p=u=4，判斷a[4] != t，因此設置p=-1。 一種例外狀況是u>=n, 好比t=9，則u=7，此時也是設置p=-1.特別注意的是，l=-1，u=n這兩個值不能寫成l=0，u=n-1。雖然這兩個值不會訪問到，可是若是改爲後面的那樣，就會致使二分查找失敗，那樣就訪問不到第一個數字。如在a={1，2，3，4，5}中查找1，若是初始設置l=0，u=n-1，則會致使查找失敗。

擴展 若是要查找數字在數組中最後出現的位置呢？其實這跟上述算法是相似的，稍微改一下上面的算法就能夠了，代碼以下：

/**
 * 二分查找最後一次出現位置
 */
int binarySearchLast(int a[], int n, int t)
{
    int l = -1, u = n;
    while (l + 1 != u) {
        /*循環不變式, a[l] <= t < a[u]*/
        int m = l + (u - l) / 2;
        if (t >= a[m])
            l = m;
        else
            u = m;
    }
    /*assert: l+1 = u && a[l] <= t < a[u]*/
    int p = l;
    if (p<=-1 || a[p]!=t)
        p = -1;
    return p;
}
複製代碼

固然還有一種方法能夠將查詢數字第一次出現和最後一次出現的代碼寫在一個程序中，只須要對原始的二分查找稍微修改便可，代碼以下：

/**
 * 二分查找第一次和最後一次出現位置
 */
int binarySearchFirstAndLast(int a[], int n, int t, int firstFlag)
{
    int l = 0;
    int u = n - 1;
    while(l <= u) {
        int m = l + (u - l) / 2;
        if(a[m] == t) { //找到了，判斷是第一次出現仍是最後一次出現
            if(firstFlag) { //查詢第一次出現的位置
                if(m != 0 && a[m-1] != t)
                    return m;
                else if(m == 0)
                    return 0;
                else
                    u = m - 1;
            } else {   //查詢最後一次出現的位置
                if(m != n-1 && a[m+1] != t)
                    return m;
                else if(m == n-1)
                    return n-1;
                else
                    l = m + 1;
            }
        }
        else if(a[m] < t)
            l = m + 1;
        else
            u = m - 1;
    }

    return -1;
}
複製代碼

3 旋轉數組元素查找問題

題目

把一個有序數組最開始的若干個元素搬到數組的末尾，咱們稱之爲數組的旋轉。例如數組{3, 4, 5, 1, 2}爲{1, 2, 3, 4, 5}的一個旋轉。如今給出旋轉後的數組和一個數，旋轉了多少位不知道，要求給出一個算法，算出給出的數在該數組中的下標，若是沒有找到這個數，則返回-1。要求查找次數不能超過n。

分析

由題目能夠知道，旋轉後的數組雖然總體無序了，可是其先後兩部分是部分有序的。由此仍是可使用二分查找來解決該問題的。

解1：兩次二分查找

首先肯定數組分割點，也就是說分割點兩邊的數組都有序。好比例子中的數組以位置2分割，前面部分{3,4,5}有序，後半部分{1,2}有序。而後對這兩部分分別使用二分查找便可。代碼以下：

/**
 * 旋轉數組查找-兩次二分查找
 */
int binarySearchRotateTwice(int a[], int n, int t)
{
    int p = findRotatePosition(a, n); //找到旋轉位置
    if (p == -1)
        return binarySearchFirst(a, n, t); //若是原數組有序，則直接二分查找便可

    int left = binarySearchFirst(a, p+1, t); //查找左半部分
    if (left != -1)
        return left; //左半部分找到，則直接返回

    int right = binarySearchFirst(a+p+1, n-p-1, t); //左半部分沒有找到，則查找右半部分
    if (right == -1)
        return -1;

    return right+p+1;  //返回位置，注意要加上p+1
}

/**
 * 查找旋轉位置
 */
int findRotatePosition(int a[], int n)
{
    int i;
    for (i = 0; i < n-1; i++) {
        if (a[i+1] < a[i])
            return i;
    }
    return -1;
}
複製代碼

解2：一次二分查找

二分查找算法有兩個關鍵點：1）數組有序；2）根據當前區間的中間元素與t的大小關係，肯定下次二分查找在前半段區間仍是後半段區間進行。

仔細分析該問題，能夠發現，每次根據 l 和 u 求出 m 後，m 左邊（[l, m]）和右邊（[m, u]）至少一個是有序的。a[m]分別與a[l]和a[u]比較，肯定哪一段是有序的。

• 若是左邊是有序的，若 t<a[m] && t>a[l], 則 u=m-1；其餘狀況，l =m+1；
• 若是右邊是有序的，若 t> a[m] && t<a[u] 則 l=m+1；其餘狀況，u =m-1； 代碼以下：

/**
 * 旋轉數組二分查找-一次二分查找
 */
int binarySearchRotateOnce(int a[], int n, int t)
{
    int l = 0, u = n-1;
    while (l <= u) {
        int m = l + (u-l) / 2;
        if (t == a[m])
            return m;
        if (a[m] >= a[l]) { //數組左半有序
            if (t >= a[l] && t < a[m])
                u = m - 1;
            else
                l = m + 1;
        } else {       //數組右半段有序
            if (t > a[m] && t <= a[u])
                l = m + 1;
            else
                u = m - 1;
        }   
    }   
    return -1; 
}
複製代碼

參考資料

• 編程珠璣第二版第九章
• 旋轉數組的二分查找