二分思想

这篇博客介绍了一种利用快速排序和二分查找算法来解决蒜头君面临的大型数组查询问题的方法。首先对数组进行排序,然后通过二分查找在查询时高效定位大于等于指定值的最小元素。这种方法适用于处理大数据量的查询请求,提高了效率并减少了时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

蒜头君手上有个长度为 n的数组 A。由于数组实在太大了,所以蒜头君也不知道数组里面有什么数字,所以蒜头君会经常询问在数组 A 中,大于等于 x 的最小值是多大?

输入格式

第一行输入两个整数 n 和 m,分别表示数组的长度和查询的次数。

接下来一行有 n 个整数 ai​。

接下来 mm 行,每行有 1 个整数 x,表示蒜头君询问的整数。

输出格式

对于每次查询,如果可以找到,输出这个整数。

否则输出 -1

数据范围

1≤n,m≤10^5,0≤x≤10^6。

输入:

10 5
1 1 1 2 3 5 5 7 8 9
0
1
4
9
10

输出:

1
1
5
9
-1

解题思路:设置快排函数和二分查找,先利用快排将数据排序后,用二分查找,mid=(low+high)/2若x值大于mid那么high=mid-1,反之low=mid+1,最后low即为查找值,之后返回输出。

#include<stdio.h>

void find(int s[],int lift,int right);
int search(int n,int num[],int x);
int main ()
{
int n,m,t,turn,i,j,k=0;
scanf("%d %d",&n,&m);
int a[n] ;
int b;
for(i=0;i<n;i++){
	scanf("%d",&a[i]);
	
}
i=0;
t=n-1;
find(a,i,t);
for(j=0;j<m;j++){
	scanf("%d",&b);
	if(b>a[n-1]){
	
	printf("-1\n");}
	else if(b<=a[0]){
	
	printf("%d\n",a[0]);}
	else {
	
	turn=search(n,a,b);
	printf("%d\n",turn);}
	}return 0 ;
}
int search(int n,int num[],int x){
	int low=0,high=n-1,mid=0;
	while(low<=high){
		mid=low+(high-low)/2;
		if(x>num[mid]){
			low=mid+1;
		}
		else if(x<=num[mid]){
			high=mid-1;
		}
	}
	return num[low];
}
void find (int s[],int lift, int right){
	if(lift<right){
		int i=lift,j=right,x=s[lift];
		while(i<j){
			while(i<j&&s[j]>=x)
			j--;
		}
		if(i<j&&s[j]<x){
			s[i++]=s[j];
		}
		while (i<j&&s[i]<=x){
		
		i++;}
		if(i<j&&s[i]>x){
		s[j--]=s[i];
	}
		s[i]=x;
		find(s,lift,i-1);
		find(s,i+1,right);
		} 
	}
	

<think>好的,我现在需要回答用户关于二分查找思想及其Java代码实现的问题。用户之前已经问过Java中的>>运算符,现在转向另一个算法相关的问题,可能是正在学习基础算法和Java编程。 首先,我需要回忆二分查找的基本概念。二分查找是一种高效的搜索算法,适用于已排序的数组或列表。它的核心思想是通过不断将搜索区间分成两半,缩小目标范围,直到找到目标元素或确定不存在。因为每次比较都能减少一半的搜索空间,所以时间复杂度是O(log n),这比线性查找的O(n)快很多。 接下来,用户可能知道二分查找的具体步骤。我需要分步骤解释:首先确定左右边界,计算中间位置,比较中间元素与目标值,根据比较结果调整左右边界,重复直到找到或区间无效。 然后,考虑Java代码的实现。需要写一个函数,接受排序好的数组和目标值,返回目标值的索引或-1。需要注意循环条件(left <= right),中间值的计算方式(防止溢出),以及边界调整(left = mid + 1 或 right = mid -1)。 同时,用户可能对边界条件和常见错误感兴趣,比如如何处理重复元素,或者中间值计算时(left + right)可能导致整数溢出的问题。这时候应该提到使用left + (right - left)/2来避免溢出。 另外,可能需要提到二分查找的变种,比如查找第一个或最后一个出现的位置,但用户的问题可能只需要基础的实现,所以暂时先不深入变种,除非用户后续提问。 还要考虑示例代码的正确性。例如,给出一个有序数组,比如[1,3,5,7,9],查找5,应该返回索引2。同时测试边缘情况,比如查找数组第一个元素或最后一个元素,或者查找不存在的元素。 在注意事项部分,需要强调数组必须是有序的,否则二分查找无法正常工作。另外,虽然时间复杂度低,但排序数组本身如果需要频繁插入或删除,可能不适合使用二分查找,因为维护有序性成本高。 最后总结二分查找的优缺点,适用场景,以及正确实现的要点。确保用户理解何时使用二分查找,以及如何正确编写代码避免常见错误。</think>以下是关于二分查找的详细说明和Java实现: --- ### 一、二分查找核心思想 二分查找(Binary Search)是一种针对**有序集合**的高效搜索算法,时间复杂度为 $O(\log n)$。其核心步骤为: 1. **区间划分**:确定搜索范围的左右边界(初始为整个数组) 2. **取中间值**:计算中间位置,比较中间元素与目标值 3. **缩小区间**: - 若中间值**等于目标** → 找到结果 - 若中间值**小于目标** → 目标在右半区间 - 若中间值**大于目标** → 目标在左半区间 4. **循环执行**:重复上述步骤,直到找到目标或区间无效 --- ### 二、Java代码实现(基础版) ```java public class BinarySearch { // 返回目标值的索引,不存在则返回-1 public static int binarySearch(int[] nums, int target) { int left = 0; int 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 { right = mid - 1; // 目标在左半区 } } return -1; // 未找到 } public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9}; System.out.println(binarySearch(arr, 5)); // 输出2 System.out.println(binarySearch(arr, 4)); // 输出-1 } } ``` --- ### 三、关键细节说明 #### 1. 循环条件 `left <= right` - 当 `left > right` 时,说明搜索区间已无效 - **错误示例**:若使用 `left < right`,当数组只有一个元素时会直接跳过循环 #### 2. 中间值计算方式 - **错误写法**:`mid = (left + right) / 2`(当 `left + right` 超过 `Integer.MAX_VALUE` 时溢出) - **正确写法**:`mid = left + (right - left) / 2` #### 3. 边界调整 - `left = mid + 1` 和 `right = mid - 1` 确保每次循环区间必然缩小 - 若写成 `right = mid` 或 `left = mid` 可能导致死循环 --- ### 四、算法特性 | 特性 | 说明 | |---------------------|--------------------------------------| | 时间复杂度 | $O(\log n)$ | | 空间复杂度 | $O(1)$(迭代实现) | | 数据要求 | **必须有序**(升序或降序排列) | | 适用场景 | 静态数据集、频繁查找、大数据量 | --- ### 五、常见问题及解决方案 #### 1. 重复元素的处理 基础版只能返回任意一个匹配位置,若需要找**第一个/最后一个出现的位置**,需使用变种算法: ```java // 查找第一个等于target的位置 int leftBound(int[] nums, int target) { int left = 0, right = nums.length - 1; while (left <= right) { int mid = left + (right - left) / 2; if (nums[mid] >= target) { right = mid - 1; } else { left = mid + 1; } } return (left < nums.length && nums[left] == target) ? left : -1; } ``` #### 2. 浮点数二分 处理精度问题时,改用固定循环次数或设定误差阈值: ```java double binarySearchDouble(double[] nums, double target) { double eps = 1e-6; double left = 0, right = nums.length - 1; while (right - left > eps) { double mid = (left + right) / 2; if (nums[mid] < target) { left = mid; } else { right = mid; } } return left; } ``` --- ### 六、总结 - **核心优势**:效率极高,适合大规模有序数据 - **注意事项**:必须保证输入数据有序,注意边界条件处理 - **扩展应用**:数学问题求根、旋转数组查找、范围查询等 通过合理运用二分思想,可以高效解决许多与有序数据相关的搜索问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值