Binary Search(二分搜索)

時間 2019-11-17

原文原文鏈接

轉載請註明出處 leonchen1024.com/2018/08/14/…git

二分搜索(binary search),也叫作折半搜索(half-interval search),對數搜索(logarithmic search),對半搜索(binary chop),是一種在有序數組中查找某一特定元素的搜索算法.github

二分搜索有幾個變體.特別是,分散層疊(fractional cascading)(將每一個數組裏的值集合成一個數組,元素爲11[0,3,2,0] 的形式,括號內的數字是該值在對應數組中應該返回的數字)提升了在多個數組中查找相同值的效率,高效的解決了一系列計算幾何和其餘領域的查找問題).指數查找(Exponential search)延伸了二分查找到一個沒有邊界的 list.binary search tree和B-tree是基於 binary search 延伸的.算法

原理

搜索時從數組中間元素開始,若是中間元素正好是要查找的元素,則搜索過程結束;若是中間元素大於或者小於要查找的元素,則在數組中大於或者小於查找元素的一半中繼續查找,重複這個過程直到找到這個元素,或者這一半的大小爲空時則表明找不到.這樣子每一次比較都使得搜索範圍縮小一半.數據庫

步驟

給定一個有序數組 A 是 A0,...,An-1並保證 A0<=...<=An-1,以及目標值 T.數組

令 L 爲0,R 爲 n-1.
若是 L>R 則搜索失敗
令m(中間值元素索引)爲最大的小於(L+R)/2的整數
若是 Am<T ,令 L=m+1並回到第2步;
若是 Am>T ,令 R=m-1並回到第2步;
當 Am=T,搜索結束;T 所在的索引位置爲m.

變體微信

令 L 爲0,R 爲 n-1.
令 m(中間元素索引) 爲上限,也就是最小的大於(L+R)/2的值.
若是 Am>T ,設置 R 爲 m-1而且返回第2步
若是 Am<=T ,設置 L 爲m 而且返回第2步.
直到 L=R ,搜索完成.這時候若是T=Am,返回 m,不然,搜索失敗.

轉載請註明出處 leonchen1024.com/2018/08/14/…數據結構

在 Am<=T 的時候,這個變體將 L 設置爲 m 而不是 m+1.這個方式的比較是更快速的,由於它在每一個循環裏省略了一次比較.可是平均就會多出來一次循環.在數組包含重複的元素的時候這個變體老是會返回最右側的元素索引.好比 A 是[1,2,3,4,4,5,6,7]查找的對象是4,那麼這個方法會返回 index 4,而不是 index 3.函數

大體匹配

因爲有序數組的順序性,能夠將二分搜索擴展到大體匹配.能夠用來計算賦值的排名(或稱秩,比它更小的元素的數量),前趨(下一個最小元素),後繼(下一個最大元素)以及最近鄰.還可使用兩個排名查詢來執行範圍查詢.性能

排名查詢可使用調整後的二分搜索來進行.成功時返回m,失敗時返回 L, 這樣就等於返回了比目標值小的元素數目.
前趨和後繼可使用排名查詢來進行.當知道目標值的排名,成功時前趨是排名位置的上一個元素,失敗時則是排名位置的元素.它的後繼是排名位置的後一個元素,或是前趨的下一個元素.目標值的最近領多是前趨或後繼,取決於哪一個更接近目標值.
範圍查詢,一旦知道範圍兩邊的值的排名,那麼大於邊界最小值且小於邊界最大值的元素排名就是他們的範圍,是否包含邊界值根據須要處理.

性能分析

時間複雜度 二分查找每次把搜索區域減小一半,時間複雜度爲編碼

(n 是集合中元素的個數) 最差的狀況是遍歷到最後一層,或者是沒有找到該元素的時候,複雜度爲 $O(\lfloor log_2 n + 1 \rfloor)$ .

綜合複雜度爲

分散層疊(fractional cascading) 能夠提升在多數組中查詢相同值的效率. k 是數組的數量,在每一個數組中查詢目標值消耗的時間.分散層疊能夠將它下降到 .

變體效率分析 相對於正常的二分搜索,它減小了每次循環的比對次數,可是它必須作完完整的循環,而不會在中間就獲得答案.可是在 n 很大的狀況下減小了對比次數的提高不可以抵消多餘的循環的消耗.

轉載請註明出處 leonchen1024.com/2018/08/14/…

空間複雜度 O(1).尾遞歸,能夠改寫爲循環.

應用

查找數組中的元素,或用於插入排序.

二分搜索和其餘的方案對比

使用二分搜索的有序數組在插入和刪除操做效率很低,每一個操做消耗 O(n) 的時間.其餘的數據結構提供了更高效的插入和刪除,而且提供了一樣高效的徹底匹配.然而,二分搜索適用於不少的搜索問題,只消耗的時間.

Hashing

對於關聯數組 (associative arrays),哈希表 (hash tables),他們是經過hash 函數將鍵映射到記錄上的數據結構,一般狀況下比在有序數組的狀況下使用二分查找要更快.大部分的實現平均開銷都是常量級的.然而, hashing 並不適用於模糊匹配,好比計算前趨,後繼,以及最近的鍵,它在失敗的查詢狀況下能給咱們的惟一信息就是目標在記錄中不存在.二分查找是這種匹配的理想模式,消耗對數級別的時間.

Trees

二叉搜索樹(binary search tree) 是一個基於二叉搜索原理的二叉樹(binary tree)數據結構.樹的記錄按照順序排列,而且每一個樹裏的每一個記錄均可以使用相似二叉搜索的方法來搜索,平均耗費對數級的時間.插入和刪除的平均時間也是對數級的.這會比有序數組消耗的線性時間要快,而且二叉樹擁有全部有序數組能夠執行的操做,包含範圍和模糊查找.

然而二叉搜索一般狀況下比二叉搜索樹的搜索更有效率,由於二叉搜索樹極可能會徹底不平衡,致使性能稍差.這一樣適用於平衡二叉搜索樹( balanced binary search trees) , 它平衡了它本身的節點稍微向徹底平衡樹靠攏.雖然不太可能,可是樹有可能只有少數節點有兩個子節點致使嚴重不平衡,這種狀況下平均時間損耗和最差的狀況差很少都是 O(n) .二叉搜索樹比有序數組佔用更多的空間.

二叉搜索樹由於能夠高效的在文件系統中結構化,因此他們能夠在硬盤中進行快速搜索.B-tree 泛化了這種樹結構的方法.B-tree 經常使用於組織長時間的存儲好比數據庫(databases)和文件系統(filesystems).

Linear search

線性搜索( Linear Search)是一種簡單的搜索算法,它查找每個記錄直到找到目標值.線性搜索能夠在鏈表(linked list) 上使用,它的插入和刪除會比在數組上要快.二分搜索比線性搜索要快除非數組很短.若是數組必須先被排序,這個消耗必須在搜索中平攤.對數組進行排序還能夠進行有效的近似匹配和其餘操做.

Set membership algorithms

一個和搜索相關的問題是集合成員(set membership).全部有關查找的算法,好比二分搜索,均可以用於集合成員.還有一些更適用於集合成員的算法,位數組(bit array)是最簡單的一個,在鍵的範圍是有限的時候很是有用.它很是快,是須要O(1)的時間.朱迪矩陣(Judy array)能夠高效的處理64位鍵.

對於近似結果,布隆過濾器(Bloom filters)是另一個基於哈希的機率性數據結構,經過存儲使用bit array 和多重 hash 函數編碼的鍵集合. Bloom filters 在大多數狀況下空間效率比bit arrays 要高而不會慢太多:使用了 k 重hash 函數,成員查找只須要 O(k) 的時間.然而, Bloom filters 有必定的誤判性.

其餘的數據結構

轉載請註明出處 leonchen1024.com/2018/08/14/…

這裏存在一些數據結構在某些狀況下比在有序數組上使用二分搜索進行查找或其餘的操做更加高效.好比,在van Emde Boas trees, fusion trees, 前綴樹(tries), 和位數組上進行查找,近似匹配,以及其餘可用的操做能夠比在有序數組上進行二分搜索更加的高效.然而,儘管這些操做能夠比在無視鍵的狀況下比有序數組上使用更高效,這樣的數據結構一般是由於利用了某些鍵的屬性(鍵一般是一些小整數),所以若是鍵缺少那些屬性將會消耗更多的空間或時間.一些結構如朱迪矩陣,使用了多種方式的組合來保證效率和執行近似匹配的能力.

變體

Uniform binary search

Uniform binary search 不是存儲下限和上限的邊界值,而是中間元素的索引,和從此次循環的中間元素到下次循環的中間元素的變化.每一步的變化減小一半.好比,要搜索的數組是[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],中間元素是6.Uniform binary search 同時對左邊和右邊的子數組進行操做.在這個狀況下,左邊的子數組([1, 2, 3, 4, 5]) 的中間元素 3 而右邊的子數組 ([7, 8, 9, 10, 11]) 的中間元素是 9.而後存儲3 做爲兩個中間元素和 6 的差異.爲了減小搜索的空間使用,算法同時加上或減去這個和中間元素的改變.這個算法的好處是能夠將每次循環的索引的差異存儲到一個表裏,在某些系統裏能夠提升算法的性能.

Exponential search

指數查找(Exponential Search)將二分搜索拓展到無邊界數組.它最開始尋找第一個索引是2的冪次方而且要比目標值大的元素的索引.而後,它將這個元素索引設置爲上邊界,而後開始二分搜索.指數查找消耗 $\lfloor log_2 x =1 \rfloor$ 次循環 ,而後二分搜索消耗 $\lfloor log_2 x \rfloor$ 次循環, x 是目標值的位置.指數查找適用於有界列表,在目標值接近數組開始的位置的時候比二分查找性能有所提升. 轉載請註明出處 leonchen1024.com/2018/08/14/…

Interpolation search

內插搜索(Interpolation search)忽略了目標值的位置,計算數組的最低和最高元素的距離即數組的長度.這隻有在數組元素是數字的時候才能使用.它適用於中間值不是最好的猜想選擇的狀況.好比,若是目標值接近數組的最高元素,最好是定位在數組的末端.若是數組的分佈是均勻的或者接近均勻的,它消耗次比較.

實際上,內插搜索在數組元素較少的狀況下是比二分搜索更慢的,由於內插搜索須要額外的計算.儘管它的時間複雜度增加是小於二分搜索的,只有在在大數組的狀況下這個計算的損耗能夠被彌補.

Fractional cascading

分散層疊(Fractional cascading) 能夠提升在多個有序數組裏查找相同的元素或近似匹配的效率,分別在每一個數組裏查找總共須要的時間, k 是數組的數量.分散層疊經過將每一個數組的信息按指定的方式存儲起來將這個時間下降到 .

轉載請註明出處 leonchen1024.com/2018/08/14/…

它將每一個數組裏的值集合成一個數組,元素爲 11[0,3,2,0] 的形式,括號內的數字是該值在對應數組中應該返回的數字)提升了在多個數組中查找相同值的效率,高效的解決了一系列計算幾何和其餘領域的查找問題

分散層疊被髮明的時候是爲了高效的解決各類計算幾何學(computational geometry) 問題,可是它一樣適用於其餘地方,例如數據挖掘(data mining) 和互聯網協議(Internet Protocal) 等.

實現時的問題

要注意中間值的取值方法,若是使用 (L+R)/2 當數組的元素數量很大的時候回形成計算溢出.因此要使用L+(R-L)/2.

示例

C 版本- 遞歸

int binary_search(const int arr[], int start , int end , int khey){
    if (start > end)
      return -1;

    int mid = start +(end - start)/2;   //直接平都可能會溢位,因此用此算法
    if (arr[mid] > khey)
        return binary_search(arr , start , mid - 1 , khey);
    else if (arr[mid] < khey)
        return binary_search(arr , mid + 1 , end , khey);
    else
        return mid;    //最後才檢測相等的狀況是由於大多數搜尋狀況不是大於就是小於

}

複製代碼

C 版本- while 循環

int binary_search(const int arr[], int start, int end, int khey){
    int result = -1;    //若是沒有搜索到數據返回 -1

    int mid;
    while (start <= end){
      mid = start + (end - start)/2 ;    //直接平都可能會溢位,因此用此算法
      if (arr[mid] > khey)
          end = mid-1;
      else if (arr[mid] < khey)
          start = mid + 1;
      else{    //最後才檢測相等的狀況是由於大多數搜尋狀況不是大於就是小於
          result = mid;
          break;
      }
    }

    return result;

}

複製代碼

Python3 遞歸

def binary_search(arr, start, end, hkey):
    if start > end:
        return -1

    mid = start + (end - start) / 2
    if arr[mid] > hkey:
        return binary_search(arr, start , mid - 1,hkey)
    if arr[mid] < hkey:
        return binary_search(arr, mid + 1, end, hkey)
    return mid

複製代碼

Python3 while 循環

def binary_search(arr, start, end, hkey):
    result = -1

    while start <= end:
        mid = start + (end - start) / 2
        if arr[mid] > hkey :
            end = mid - 1
        elif arr[mid] < hkey :
            start = mid + 1
        else :
            result = mid
            break

    return result

複製代碼

Java 遞歸

public static int binarySearch(int[] arr, int start, int end, int hkey){
    if (start > end)
        return -1;

    int mid = start + (end - start)/2;    //防止溢位
    if (arr[mid] > hkey)
        return binarySearch(arr, start, mid - 1, hkey);
    if (arr[mid] < hkey)
        return binarySearch(arr, mid + 1, end, hkey);
    return mid;  

}

複製代碼

Java while 循環

public static int binarySearch(int[] arr, int start, int end, int hkey){
    int result = -1;

    while (start <= end){
        int mid = start + (end - start)/2;    //防止溢位
        if (arr[mid] > hkey)
            end = mid - 1;
        else if (arr[mid] < hkey)
            start = mid + 1;
        else {
            result = mid ;  
            break;
        }
    }

    return result;

}

複製代碼