二分搜索面试题C++

二分搜索的常见考察点

1. 对于边界条件的考察以及代码实现的能力，如果边界条件处理不当，可能会出现死循环或者漏掉某个数的情况。仔细设计中间划分点的逻辑判断以及循环的终止条件，防止出现循环永远不能终止的情况。
2. 在有序循环数组中进行二分搜索
   循环数组是指，1,2,3,4,5的任意前部分放到数组后，例如，23451,34512,45123,51234.

二分搜索的重要提醒

一般的中点选取为$mid=(left+right)/2$，这种写法当数组比较大时，可能会溢出，更安全的写法为
$$mid=left+(right-left)/2$$

示例一

给定一个无序数组arr，已知任意相邻的两个元素值都不重复。请返回任意一个局部最小位置。
如果两头的旁边大，则两头是局部最小值，如果中间位置的两侧大于中间位置，则中间位置为局部最小值。
分析：使用二分搜索，时间复杂度为$O(logN)$。
1.arr为空或长度为0，返回-1，表示局部最小不存在
2.如果arr长度为1，返回0，此时0为局部最小。
3.如果arr长度大于1
a.首先判断两边。
b.

如果中间的数大于它左边的数，可以往左边搜索局部最小位置。

如果中间的数大于它右边的数，可以往右边搜索局部最小位置。

如果中间的数比两边的数都大，可以往任意方向搜索。

template int minIndex(const T *arr, const int &length) {//搜索局部最小
	if (length == 0) {
		return -1;
	}
	if (length == 1) {
		return 0;
	}
	if (arr[0] < arr[1]) {
		return 0;
	}
	if (arr[length - 1] < arr[length - 2]) {
		return length - 1;
	}
	int left = 0;
	int right = length - 1;
	while ((left - right) > 1){
		int mid = left + (right - left) / 2;
		if ((arr[mid] < arr[mid - 1]) && (arr[mid] < arr[mid + 1])) {
			return mid;
		}
		if (arr[mid] > arr[mid - 1]) {
			right = mid-1;
		}
		else if(arr[mid]>arr[mid+1]){
			left = mid+1;
		}
	}
	return -1;
}

示例二

给定一个有序数组arr，再给定一个整数num，请在arr中找到num这个数出现的最左边的位置。
分析：设计一个变量记录num最后一次出现的位置，当mid大于等于num时往左边搜索，当min小于num时往右边搜索。

template int findLeftIndex(const T *arr, const int &length,const T &value) {
	int result = -1;
	if (length == 0) {
		return result;
	}
	int left = 0;
	int right = length - 1;
	while (left!=right){
		int mid = left + (right - left) / 2;
		if (arr[mid] == value) {
			result = mid;
		}
		if (arr[mid] >= value) {
			right = mid;
		}
		else{
			left = mid + 1;
		}
	}
	if (arr[left] == value) {
		result = left;
	}
	return result;
}

示例三

给定一个有序循环数组arr，返回arr中的最小值。有序循环数组是指，有序数组左边的任意长度的部分放到右边去，右边的部分拿到左边来。比如数组[1,2,3,3,4]是有序数组，[4,1,2,3,3]也是。
分析：
1.当arr[L]< arr[R]，整段数组有序，返回arr[L]。
2.当arr[L] >= arr[R]
a.若arr[L]>arr[M]，最小值在L到M之间。
b.若arr[M]>arr[R]，最小值在M到R之间。
c.若arr[M]>=arr[L]且arr[R]>=arr[M]时，arr[L]=arr[M]=arr[L]，三值相等，只能从L遍历到R查找最小值。

template T findSortCurrentArrayMinValue(T *sortArray, const int &length) {
	if (length == 0) {
		return -1;
	}
	if (length == 1) {
		return 0;
	}
	int left = 0;
	int right = length - 1;
	while (left sortArray[right]) {
				return right;
			}
		}
		if (sortArray[left] < sortArray[right]) {
			return left;
		}
		else {
			int middle = left + (right - left) / 2;
			if (sortArray[left] > sortArray[middle]) {
				right = middle;
				continue;
			}
			else if (sortArray[middle] > sortArray[right]) {
				left = middle;
				continue;
			}
			else {
				int minIndex = left;
				for (int i = left; i <= right; ++i) {
					if (sortArray[minIndex] > sortArray[i]) {
						minIndex = i;
					}
				}
				return minIndex;
			}
		}
	}
	return -1;
}

示例四

给定一个有序整数数组arr，共N个元素，其中不含有重复元素，请找到满足arr[i]==i条件的最左位置，如果所有位置上的数都不满足条件，返回-1。
分析：
1.如果arr[0]>N-1，返回-1
2.如果arr[N-1]<0，返回-1
3.如果arr[M]>M，则在M到R中不可能出现。
4.如果arr[M] 5.如果arr[M]=M，记录当前M，然后在L到M中搜索。

template int findValueEqualIndex(T *sortArray, const int &length) {
	int result = -1;
	if (sortArray[0] > 0) {
		return result;
	}
	if (sortArray[length - 1] < length - 1) {
		return result;
	}
	int left = 0;
	int right = length - 1;
	while (left= middle) {
			right = middle;
		}
		else {
			left = middle;
		}
	}
	if (sortArray[left] == left) {
		result = left;
	}
	else if (sortArray[right] == right) {
		result = right;
	}
	return result;
}

示例五

如何更快的求一个整数k的N次方，如果两个整数相乘并得到结果的时间复杂度为$O(1)$，得到整数k的N次方的过程请实现时间复杂度为$O(logN)$的方法。
分析：
$10^{75}=10^{1001011(75的二进制)}=10^{1000000}\ast 10^{1000}\ast 10^{10}\ast 10^1=10^{64}\ast 10^8\ast 10^2\ast 10^1$

int mPowerK(const int &m, const int &k) {
	unsigned int temK = k;
	std::vector binaryVector;
	std::vector powerVector;
	if (k == 0) {
		return 1;
	}
	if (k == 1) {
		return m;
	}
	while (temK!=0){
		binaryVector.push_back((temK&1));
		temK = temK >> 1;
	}
	powerVector.push_back(m);
	for (std::size_t i = 1; i < binaryVector.size(); ++i) {
		powerVector.push_back(powerVector[i - 1] * powerVector[i - 1]);
	}
	int result = 1;
	for (std::size_t i = 0; i < binaryVector.size(); ++i) {
		if (binaryVector[i]) {
			result *= powerVector[i];
		}
	}
	return result;
}

示例六

从两个有序数组A,B中，寻找第k小的元素。数组长度分别为M与N。
分析：可以使用二分法，时间复杂度为$O(logM+logN)$。
若满足$i+j+1=k$，有以下四种情况

1. A[i-1]，则B[j]为第k小的元素；
2. B[j-1]，则A[i]为第k小的元素。
3. 在1,2不满足情况下，若A[i]，则A[i]左侧与B[j]右侧可以抛弃。
4. 在1,2,3不满足情况下，若B[j]，则B[j]左侧与A[i]右侧可以抛弃。

int findKthSmallest(int *a,const int &m, int *b,const int &n, const int &k) {
	if (m < 0 || n < 0 || m + n < k) {
		return -999;
	}
	int i = static_cast(static_cast(m) / static_cast(m + n) * (k - 1));
	int j = k - 1 - i;
	int ai_1 = ((i == 0) ? INT16_MIN : a[i-1]);
	int bj_1 = ((j == 0) ? INT16_MIN : b[j-1]);
	int ai = ((i == m) ? INT16_MAX : a[i]);
	int bj = ((j == n) ? INT16_MAX : b[j]);
	if (ai > bj_1&&ai < bj) {
		return ai;
	}
	if (bj > ai_1&&ai > bj) {
		return bj;
	}
	if (ai < bj) {
		return findKthSmallest(a + 1 + i, m - i - 1, b, j, k - i - 1);
	}
	if (bj < ai) {
		return findKthSmallest(a, i, b - j - 1, n - j - 1, k - j - 1);
	}

}