1. 程式人生 > >二分查詢法的實現和應用匯總

二分查詢法的實現和應用匯總

到目前位置,似乎我們學到的演算法中,時間複雜度是O(log n),好像就數二分查詢法,其他的諸如排序演算法都是 O(n log n)或者O(n2)。但是也正是因為有二分的 O(log n), 才讓很多 O(n2)縮減到只要O(n log n)。

關於二分查詢法

二分查詢法主要是解決在“一堆數中找出指定的數”這類問題。

而想要應用二分查詢法,這“一堆數”必須有一下特徵:

  • 儲存在陣列中
  • 有序排列

所以如果是用連結串列儲存的,就無法在其上應用二分查詢法了。

至於是順序遞增排列還是遞減排列,陣列中是否存在相同的元素都不要緊。不過一般情況,我們還是希望並假設陣列是遞增排列,陣列中的元素互不相同。

二分查詢法的基本實現

二分查詢法屬於“分治法”,分治法基本都可以用遞迴來實現的,二分查詢法的遞迴實現如下:

int binarysearch(int array[], int low, int high, int key){
	if (low > high) return -1;

	int mid = (low + high) / 2;
	if (array[mid]> key)
		return    binarysearch(array, low, mid - 1, key);
	else if (array[mid]< key)
		return    binarysearch(array, mid + 1, high, key);

	//if (midValue == target)
	return mid;
}

因為二分的遞迴其實是尾遞迴,它不關心遞迴前的所有資訊。所以它的非遞迴實現甚至可以不用棧

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;
	while (high > low){
		mid = (low + high) / 2;
		if (array[mid] > target)
			high = mid;
		else
			low = mid + 1;
	}

	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; //make mid lean to large side
	while (low < high){
		mid = (low + high + 1) / 2;
		if (array[mid] < target)
			low = mid;
		else
			high = mid - 1;
	}

	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))的搜尋目標數。