今日分享 整数二分

  1. 二分法的核心思想

二分法就像猜数字游戏。每次猜中间数,根据大小提示排除一半答案。

这种方法将 O(n) 的线性查找,优化到 O(log n) 的对数级别。

  1. 整数二分的"奥义"

整数二分的精髓在于边界处理。因为整数没有"中点",必须明确:

查找区间是 [left, right] (闭区间)

每次排除时,边界如何更新才不会漏掉答案

处理不好边界,就会导致死循环或漏掉正确答案。

  1. 两种经典模板与技巧

根据要找的目标不同,分为两种模板:

模板一:查找第一个满足条件的值

用于查找"左边界",例如:数组中第一个大于等于 x 的数。

int findFirst(int *nums, int n, int x) {

int left = 0, right = n - 1;

int ans = n; // 初始化为一个不可能的位置

while (left <= right) {

int mid = left + (right - left) / 2; // 防止溢出

if (nums[mid] >= x) { // 满足条件,尝试找更左边的

ans = mid;

right = mid - 1;

} else { // 不满足,去右边找

left = mid + 1;

}

}

return ans;

}

模板二:查找最后一个满足条件的值

用于查找"右边界",例如:数组中最后一个小于等于 x 的数。

int findLast(int *nums, int n, int x) {

int left = 0, right = n - 1;

int ans = -1; // 初始化为一个不可能的位置

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] <= x) { // 满足条件,尝试找更右边的

ans = mid;

left = mid + 1;

} else { // 不满足,去左边找

right = mid - 1;

}

}

return ans;

}

  1. 解题技巧总结

  2. 确定区间:永远使用闭区间 [left, right] ,逻辑最清晰。

  3. 循环条件:使用 left <= right ,保证退出时所有元素都被检查。

  4. 计算中点:用 mid = left + (right - left) / 2 避免 left + right 溢出。

  5. 边界移动:根据"找左边界"还是"找右边界"选择移动 left 或 right 。

  6. 验证答案:退出循环后,记得检查 ans 是否在合理范围内。

例题实战:在排序数组中查找元素的第一个和最后一个位置

题目描述:

给定一个按照升序排列的整数数组 nums ,和一个目标值 target 。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值,返回 [-1, -1] 。

示例:

输入: nums = [5,7,7,8,8,10] , target = 8

输出: [3, 4]

C 语言实现

#include <stdio.h>

#include <stdlib.h>

int* searchRange(int* nums, int numsSize, int target, int* returnSize) {

*returnSize = 2;

int* result = (int*)malloc(sizeof(int) * 2);

result[0] = -1;

result[1] = -1;

// 找左边界

int left = 0, right = numsSize - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] >= target) {

right = mid - 1;

} else {

left = mid + 1;

}

}

if (left < numsSize && nums[left] == target) {

result[0] = left;

} else {

return result;

}

// 找右边界

left = 0;

right = numsSize - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] <= target) {

left = mid + 1;

} else {

right = mid - 1;

}

}

result[1] = right;

return result;

}

int main() {

int nums[] = {5,7,7,8,8,10};

int target = 8;

int returnSize;

int* result = searchRange(nums, 6, target, &returnSize);

printf("[%d, %d]\n", result[0], result[1]);

free(result);

return 0;

}

C++ 实现

#include <iostream>

#include <vector>

using namespace std;

vector<int> searchRange(vector<int>& nums, int target) {

vector<int> result(2, -1);

int n = nums.size();

if (n == 0) return result;

// 找左边界

int left = 0, right = n - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] >= target) {

right = mid - 1;

} else {

left = mid + 1;

}

}

if (left < n && nums[left] == target) {

result[0] = left;

} else {

return result;

}

// 找右边界

left = 0;

right = n - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] <= target) {

left = mid + 1;

} else {

right = mid - 1;

}

}

result[1] = right;

return result;

}

int main() {

vector<int> nums = {5,7,7,8,8,10};

int target = 8;

vector<int> res = searchRange(nums, target);

cout << "[" << res[0] << ", " << res[1] << "]" << endl;

return 0;

}

Python 实现

def searchRange(nums, target):

result = [-1, -1]

n = len(nums)

if n == 0:

return result

找左边界

left, right = 0, n - 1

while left <= right:

mid = left + (right - left) // 2

if nums[mid] >= target:

right = mid - 1

else:

left = mid + 1

if left < n and nums[left] == target:

result[0] = left

else:

return result

找右边界

left, right = 0, n - 1

while left <= right:

mid = left + (right - left) // 2

if nums[mid] <= target:

left = mid + 1

else:

right = mid - 1

result[1] = right

return result

nums = [5,7,7,8,8,10]

target = 8

print(searchRange(nums, target))

Java 实现

import java.util.Arrays;

public class SearchRange {

public static int[] searchRange(int[] nums, int target) {

int[] result = {-1, -1};

int n = nums.length;

if (n == 0) return result;

// 找左边界

int left = 0, right = n - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] >= target) {

right = mid - 1;

} else {

left = mid + 1;

}

}

if (left < n && nums[left] == target) {

result[0] = left;

} else {

return result;

}

// 找右边界

left = 0;

right = n - 1;

while (left <= right) {

int mid = left + (right - left) / 2;

if (nums[mid] <= target) {

left = mid + 1;

} else {

right = mid - 1;

}

}

result[1] = right;

return result;

}

public static void main(String[] args) {

int[] nums = {5,7,7,8,8,10};

int target = 8;

int[] res = searchRange(nums, target);

System.out.println(Arrays.toString(res));

}

}

相关推荐
little~钰2 小时前
树上倍增和LCA算法---上
算法
mc23562 小时前
5分钟学会微算法——Brian Kernighan 算法
算法
Excuse_lighttime2 小时前
除自身以外数组的乘积
java·数据结构·算法·leetcode·eclipse·动态规划
万添裁2 小时前
归并排序的三重境界
数据结构·算法
程序员三明治2 小时前
【重学数据结构】队列 Queue
数据结构·后端·算法
Coision.2 小时前
Linux C: 函数
java·c语言·算法
杜小暑2 小时前
数据结构之双向链表
c语言·数据结构·后端·算法·链表·动态内存管理
AndrewHZ3 小时前
【3D图像技术讨论】3A游戏场景重建实战指南:从数据采集到实时渲染的开源方案
人工智能·算法·游戏·3d·开源·llm·colmap
Juan_20123 小时前
P3051题解
c++·数学·算法·题解