在學習算法的過程中，我們除了要了解某個算法的基本原理、實現方式，更重要的一個環節是利用big-O理論來分析算法的復雜度。在時間復雜度和空間復雜度之間，我們又會更注重時間復雜度。
時間復雜度按優劣排差不多集中在：
O(1), O(log n), O(n), O(n log n), O(n2), O(nk), O(2n)
到目前位置，似乎我學到的算法中，時間復雜度是O(log n),好像就數二分查找法，其他的諸如排序算法都是 O(n log n)或者O(n2)。但是也正是因為有二分的 O(log n), 才讓很多 O(n2)縮減到只要O(n log n)。
關於二分查找法
二分查找法主要是解決在“一堆數中找出指定的數”這類問題。
而想要應用二分查找法，這“一堆數”必須有一下特征：
- 存儲在數組中
- 有序排列
所以如果是用鏈表存儲的，就無法在其上應用二分查找法了。（曽在面試被問二分查找法可以什么數據結構上使用：數組？鏈表？）
至於是順序遞增排列還是遞減排列，數組中是否存在相同的元素都不要緊。不過一般情況，我們還是希望並假設數組是遞增排列，數組中的元素互不相同。
二分查找法的基本實現
二分查找法在算法家族大類中屬於“分治法”，分治法基本都可以用遞歸來實現的，二分查找法的遞歸實現如下：
int bsearch(int array[], int low, int high, int target)
{
if (low > high) return -1;
int mid = (low + high)/2;
if (array[mid]> target)
return binarysearch(array, low, mid -1, target);
if (array[mid]< target)
return binarysearch(array, mid+1, high, target);
//if (midValue == target)
return mid;
}
不過所有的遞歸都可以自行定義stack來解遞歸，所以二分查找法也可以不用遞歸實現，而且它的非遞歸實現甚至可以不用棧，因為二分的遞歸其實是尾遞歸，它不關心遞歸前的所有信息。
int bsearchWithoutRecursion(int array[], int low, int high, int target)
{
while(low <= high)
{
int mid = (low + high)/2;
if (array[mid] > target)
high = mid - 1;
else if (array[mid] < target)
low = mid + 1;
else //find the target
return mid;
}
//the array does not contain the target
return -1;
}
只用小於比較（<）實現二分查找法
在前面的二分查找實現中，我們既用到了小於比較（<）也用到了大於比較（>），也可能還需要相等比較（==）。
而實際上我們只需要一個小於比較（<）就可以。因為錯邏輯上講a>b和b<a應該是有相當的邏輯值；而a==b則是等價於 !((a<b)||(b<a))，也就是說a既不小於b，也不大於b。
當然在程序的世界里， 這種關系邏輯其實並不是完全正確。另外，C++還允許對對象進行運算符的重載，因此開發人員完全可以隨意設計和實現這些關系運算符的邏輯值。
不過在整型數據面前，這些關系運算符之間的邏輯關系還是成立的，而且在開發過程中，我們還是會遵循這些邏輯等價關系來重載關系運算符。
干嘛要搞得那么羞澀，只用一個關系運算符呢？因為這樣可以為二分查找法寫一個template，又能減少對目標對象的要求。模板會是這樣的：
template <typename T, typename V>
inline int BSearch(T& array, int low, int high, V& target)
{
while(!(high < low))
{
int mid = (low + high)/2;
if (target < array[mid])
high = mid - 1;
else if (array[mid] < target)
low = mid + 1;
else //find the target
return mid;
}
//the array does not contain the target
return -1;
}
我們只需要求target的類型V有重載小於運算符就可以。而對於V的集合類型T，則需要有[]運算符的重載。當然其內部實現必須是O(1)的復雜度，否則也就失去了二分查找的效率。
用二分查找法找尋邊界值
之前的都是在數組中找到一個數要與目標相等，如果不存在則返回-1。我們也可以用二分查找法找尋邊界值，也就是說在有序數組中找到“正好大於（小於）目標數”的那個數。
用數學的表述方式就是：
在集合中找到一個大於（小於）目標數t的數x，使得集合中的任意數要么大於（小於）等於x，要么小於（大於）等於t。
舉例來說：
給予數組和目標數
int array = {2, 3, 5, 7, 11, 13, 17};
int target = 7;
那么上界值應該是11，因為它“剛剛好”大於7；下屆值則是5，因為它“剛剛好”小於7。
用二分查找法找尋上屆
//Find the fisrt element, whose value is larger than target, in a sorted array
int BSearchUpperBound(int array[], int low, int high, int target)
{
//Array is empty or target is larger than any every element in array
if(low > high || target >= array[high]) return -1;
int mid = (low + high) / 2;
while (high > low)
{
if (array[mid] > target)
high = mid;
else
low = mid + 1;
mid = (low + high) / 2;
}
return mid;
}
與精確查找不同之處在於，精確查找分成三類：大於，小於，等於（目標數）。而界限查找則分成了兩類：大於和不大於。
如果當前找到的數大於目標數時，它可能就是我們要找的數，所以需要保留這個索引，也因此if (array[mid] > target)時 high=mid; 而沒有減1。
用二分查找法找尋下屆
//Find the last element, whose value is less than target, in a sorted array
int BSearchLowerBound(int array[], int low, int high, int target)
{
//Array is empty or target is less than any every element in array
if(high < low || target <= array[low]) return -1;
int mid = (low + high + 1) / 2; //make mid lean to large side
while (low < high)
{
if (array[mid] < target)
low = mid;
else
high = mid - 1;
mid = (low + high + 1) / 2;
}
return mid;
}
下屆尋找基本與上屆相同，需要注意的是在取中間索引時，使用了向上取整。若同之前一樣使用向下取整，那么當low == high-1，而array[low] 又小於 target時就會形成死循環。因為low無法往上爬超過high。
這兩個實現都是找嚴格界限，也就是要大於或者小於。如果要找松散界限，也就是找到大於等於或者小於等於的值（即包含自身），只要對代碼稍作修改就好了：
去掉判斷數組邊界的等號：
target >= array[high]改為 target > array[high]
在與中間值的比較中加上等號：
array[mid] > target改為array[mid] >= target
用二分查找法找尋區域
之前我們使用二分查找法時，都是基於數組中的元素各不相同。假如存在重復數據，而數組依然有序，那么我們還是可以用二分查找法判別目標數是否存在。不過，返回的index就只能是隨機的重復數據中的某一個。
此時，我們會希望知道有多少個目標數存在。或者說我們希望數組的區域。
結合前面的界限查找，我們只要找到目標數的嚴格上屆和嚴格下屆，那么界限之間（不包括界限）的數據就是目標數的區域了。
//return type: pair<int, int>
//the fisrt value indicate the begining of range,
//the second value indicate the end of range.
//If target is not find, (-1,-1) will be returned
pair<int, int> SearchRange(int A[], int n, int target)
{
pair<int, int> r(-1, -1);
if (n <= 0) return r;
int lower = BSearchLowerBound(A, 0, n-1, target);
lower = lower + 1; //move to next element
if(A[lower] == target)
r.first = lower;
else //target is not in the array
return r;
int upper = BSearchUpperBound(A, 0, n-1, target);
upper = upper < 0? (n-1):(upper - 1); //move to previous element
//since in previous search we had check whether the target is
//in the array or not, we do not need to check it here again
r.second = upper;
return r;
}
它的時間復雜度是兩次二分查找所用時間的和，也就是O(log n) + O(log n)，最后還是O(log n)。
在輪轉后的有序數組上應用二分查找法
之前我們說過二分法是要應用在有序的數組上，如果是無序的，那么比較和二分就沒有意義了。
不過還有一種特殊的數組上也同樣可以應用，那就是“輪轉后的有序數組（Rotated Sorted Array）”。它是有序數組，取期中某一個數為軸，將其之前的所有數都輪轉到數組的末尾所得。比如{7, 11, 13, 17, 2, 3, 5}就是一個輪轉后的有序數組。非嚴格意義上講，有序數組也屬於輪轉后的有序數組——我們取首元素作為軸進行輪轉。
下邊就是二分查找法在輪轉后的有序數組上的實現（假設數組中不存在相同的元素）
int SearchInRotatedSortedArray(int array[], int low, int high, int target)
{
while(low <= high)
{
int mid = (low + high) / 2;
if (target < array[mid])
if (array[mid] < array[high])//the higher part is sorted
high = mid - 1; //the target would only be in lower part
else //the lower part is sorted
if(target < array[low])//the target is less than all elements in low part
low = mid + 1;
else
high = mid - 1;
else if(array[mid] < target)
if (array[low] < array[mid])// the lower part is sorted
low = mid + 1; //the target would only be in higher part
else //the higher part is sorted
if (array[high] < target)//the target is larger than all elements in higher part
high = mid - 1;
else
low = mid + 1;
else //if(array[mid] == target)
return mid;
}
return -1;
}
對比普通的二分查找法，為了確定目標數會落在二分后的那個部分，我們需要更多的判定條件。但是我們還是實現了O(log n)的目標。
二分查找法的缺陷
二分查找法的O(log n)讓它成為十分高效的算法。不過它的缺陷卻也是那么明顯的。就在它的限定之上：
必須有序，我們很難保證我們的數組都是有序的。當然可以在構建數組的時候進行排序，可是又落到了第二個瓶頸上：它必須是數組。
數組讀取效率是O(1)，可是它的插入和刪除某個元素的效率卻是O(n)。因而導致構建有序數組變成低效的事情。
解決這些缺陷問題更好的方法應該是使用二叉查找樹了，最好自然是自平衡二叉查找樹了，自能高效的（O(n log n)）構建有序元素集合，又能如同二分查找法一樣快速（O(log n)）的搜尋目標數。