算法-二分查找

二分查找框架：

int binarySearch(int[] nums, int target) {
	int left = 0, right = ...;
	while(...) {
		int mid = left + (right - left) / 2;
		if (nums[mid] == target) {
			...
		} else if (nums[mid] < target) {
			left = ...
		} else if (nums[mid] > target) {
			right = ...
		}
	}
	return ...;
}

计算 mid 时需要防止溢出，代码中 left + (right - left) / 2 就和 (left + right) / 2 的结果相同，但是有效防止了 left 和 right 太大直接相加导致溢出。

寻找一个数：
leetcode 704. 二分查找

public int search(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        }
    }
    return -1;
}

• 算法中初始化 right = nums.length - 1 决定了我们的搜索区间是闭区间 [left, right] ，即 while (left <= right) 。
• 同时由于mid位置已经搜索过，所以直接搜索mid周围即可：left = mid + 1 和 right = mid - 1 。
• 因为我们只需找到⼀个 target 的索引即可，所以当 nums[mid] == target 时可以⽴即返回。

寻找左侧边界的二分搜索：

• 算法的改动为找到 target 后，不直接返回，而是缩小上界，即将 mid 赋值给 right。

// 左闭右开区间的写法
int left_bound(int[] nums, int target) {
	if (nums.length == 0) return -1;
	int left = 0;
	// right取不到 nums.length
	int right = nums.length;
	// 左闭右开 [left, right)
	while (left < right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] == target) {
			right = mid;
		} else if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
			right = mid;
		}
	}
	return left;
}

搜索区间是 [left, right) 左闭右开，所以当 nums[mid] 被检测之 后，下⼀步的搜索区间应该去掉 mid 分割成两个区间，即 [left, mid) 或 [mid + 1, right)。

左侧为 闭区间 ，同时由于终止条件为 left == right ，所以直接返回 left 即可。

// 闭区间写法
public int leftBound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    // [left, right]
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            right = mid - 1;
        }
    }
    // 判断出界情况
    if (left >= nums.length || nums[left] != target) {
        return -1;
    }
    return left;
}

返回前需判断出界情况，由于终止条件为 left > right , 所以不止要判断 nums[left] != target ，还要判断 left 是否已出界，出界即 left >= nums.length（nums.length 取不到）。

寻找右侧边界的二分搜索：

• 算法的改动为找到 target 后，不直接返回，而是扩大下界，即将 mid 赋值给 left + 1。

// 左闭右开区间的写法
int right_bound(int[] nums, int target) {
	if (nums.length == 0) return -1;
	// right取不到 nums.length
	int left = 0, right = nums.length;
	// 左闭右开 [left, right)
	while (left < right) {
		int mid = left + (right - left) / 2;
		if (nums[mid] == target) {
			left = mid + 1;
		} else if (nums[mid] < target) {
			left = mid + 1;
		} else if (nums[mid] > target) {
			right = mid;
		}
	}
	return left - 1;
}

左侧为 闭区间 ，同时由于终止条件为 left == right ，又由于找到边界时还是会执行 left = mid + 1 ，就是说 while 循环结束时，nums[left] ⼀定不等于target 了，⽽ nums[left-1] 可能是 target，所以需要返回 left - 1 。

// 闭区间写法
public int rightBound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    // [left, right]
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            left = mid + 1;
        }
    }
    // 判断出界情况
    if (right < 0 || nums[right] != target) {
        return -1;
    }
    return right;
}

返回前需判断出界情况，由于终止条件为 left > right , 所以不止要判断 nums[right] != target ，还要判断 right 是否已出界，出界即 right < 0 。