1.14 LeetCode总结（基本算法）_二分查找类

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

思路：此题是非常经典的二分查找题目，需要重点掌握：

二分查找：

int search(int *nums, int numsSize, int target)
{
	int l = 0;            // low
	int h = numsSize - 1; // high
	int m = 0;            // medium

	while (l <= h)
	{
		m = l + (h - l) / 2;        // 手法1：m 的处理
		if (target > nums[m]) {
			l = m + 1;              // 手法2：l 的处理
		}
		else if (target < nums[m])
		{
			h = m - 1;              // 手法3：h 的处理
		}
		else if (target == nums[m])
		{
			return m;
		}
	}

	return -1; // 没有找到该元素，返回-1.
}

278. 第一个错误的版本

思路是先找到第一个出错的版本，即 isBadVersion == true. 然后找它的下一个 false 即为所求。，但效率有点低，特别对于第一次如果找到的 true 比较靠前，将多走很多步才能找到下一个 false 的下标。

// 法1：效率不高，但能通过
int firstBadVersion(int n)
{
	int l = 0;            // low
	int h = n - 1;        // high
	int m = 0;            // medium
	int trueFlag = 0;
	
	while (l <= h)
	{
		m = l + (h - l) / 2;
		if (isBadVersion(m) == false) {
			l = m + 1;
		}
		else if (isBadVersion(m) == true)
		{
			h = m - 1;
			break;
		}
	}
	// 找到第一个 true 后，遍历得到第一个 false 的元素即为 第一个错误起始位置。
	while (m >= 0 && (isBadVersion(m) == true)) {
		m--;
	}

	return (m + 1);
}

法2效率高很多，通过不断收缩边界来做，当不满足while的(l <= h)时，l的下标即是所求解的起始下标.

// 法2：效率高
int firstBadVersion(int n)
{
	int l = 1;            // low
	int h = n;            // high
	int m = 0;            // medium

	while (l <= h)
	{
		m = l + (h - l) / 2;
		if (isBadVersion(m) == false) {       // 收缩右边界
			l = m + 1;
		} else if (isBadVersion(m) == true) { // 收缩左边界
			h = m - 1;
		}
	}

	return l; // 手法：这里是返回l
}

这上下两题真的非常重要，告知了一种二分求解的思路，最后的下标 l 就是 “第一个错误的版本”，或者说就是那个 limit 水线，或者说就是搜索插入位置的下标，二分查找用于其他算法题里时，就是用来快速找到这个水线的位置， 考试题优化也是考察了这里！

35. 搜索插入位置

int searchInsert(int *nums, int numsSize, int target)
{
	int l = 0;
	int h = numsSize - 1;
	int m;

	while (l <= h) {
		m = l + (h - l) / 2;
		if (nums[m] < target) {
			l = m + 1;
		}
		else if (nums[m] >= target){
			h = m - 1;
		}
	}

	return l;
}

2389. 和有限的最长子序列

static int cmp(const void *pa, const void *pb) {
    return *(int *)pa - *(int *)pb;
}

int binarySearch(int *arr, int arrSize, int target) {
    int low = 1, high = arrSize;
    while (low < high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] > target) {
            high = mid;
        } else {
            low = mid + 1;
        }
    }
    return low;
}

int *answerQueries(int *nums, int numsSize, int *queries, int queriesSize, int *returnSize) {
    qsort(nums, numsSize, sizeof(int), cmp);
    int f[numsSize + 1];
    f[0] = 0;
    for (int i = 0; i < numsSize; i++) {
        f[i + 1] = f[i] + nums[i];
    }
    int *answer = (int *)calloc(sizeof(int), queriesSize);
    for (int i = 0; i < queriesSize; i++) {
        answer[i] = binarySearch(f, numsSize + 1, queries[i]) - 1;
    }
    *returnSize = queriesSize;
    return answer;
}