有关二分查找的边界思考

1、二分查找概念

二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

2、二分查找简单实现

(1)左开右闭 【 )

//非递归版本
int* BinarySearch(int *a,int n,int key)
{
	if (a==NULL||n==0)
	{
		return NULL;
	}
	//[)
	int left=0;
	int right=n;
	while(left<right) //如果写成left<=right 有可能越界
	{
		int mid=left+(right-left)/2;
		if (a[mid]>key)
		{
			right=mid;     
			//如果写成right=mid+1 元素如果是a[0]=0,a[1]=1,要找1
			//left=0,right=1,mid=0
			//然后a[mid]<1,right=mid;此时找不到1,因为left<right
			//所以当为【)不要把未判断元素直接做right的下标
		}
		else if(a[mid]<key)
		{
			left=mid+1;
		}
		else
		{
			return a+mid;
		}
	}
	return NULL;
}
void testBinary()
{
	int a[10]={0,1,3,5,45,78,98,111,121,454};
	for (int i=9;i>=0;i--)
	{
		int *temp=BinarySearch(a,10,i);
		if(temp==NULL)
		{
			cout<<"NULL"<<endl;
		}
		else
			cout<<*temp<<endl;
	}
}
//递归版本
int * BinarySearch_R(int *a,int n,int key,int left,int right)
{
    if(a==NULL||n==0)
    {
        return NULL;
    }
    if(left<right)
    {
        int mid=left+(right-left)/2;
        if(a[mid]>key)
        {
            return BinarySearch_R(a,n,key,left,mid);
        }
        else if(a[mid]<key)
        {
            return BinarySearch_R(a,n,key,mid+1,right);
        }
        else
        {
            return a+mid;
        }
    }
    else
    {
        return NULL;
    }
}

void testBinary_R()
{
	int a[10]={0,1,3,5,45,78,98,111,121,454};
	for (int i=9;i>=0;i--)
	{
		int *temp=BinarySearch_R(a,10,i,0,10);
		if(temp==NULL)
		{
			cout<<"NULL"<<endl;
		}
		else
			cout<<*temp<<endl;
	}
}

(2)左闭右闭 【】

int* BinarySearch_C(int *a,int n,int key)
{
    if(a==NULL||n==0)
    {
        return NULL;
    }
    //[]
    int left=0;
    int right=n-1;
    while(left<=right)
    {
        int mid=left+(right-left)/2;
        if(a[mid]>key)
        {
            right=mid-1; //a[mid]的值已经判断过了
        }
        else if(a[mid]<key)
        {
            left=mid+1; //a[mid]已经判断过了
        }
        else
            return a+mid;
    }
    return NULL;
}

void testBinary()
{
	int a[10]={0,1,3,5,45,78,98,111,121,454};
	for (int i=9;i>=0;i--)
	{
		int *temp=BinarySearch_C(a,10,i);
		if(temp==NULL)
		{
			cout<<"NULL"<<endl;
		}
		else
			cout<<*temp<<endl;
	}
}

//递归版本
int * BinarySearch_CR(int *a,int n,int key,int left,int right)
{
    if(a==NULL||n==0)
    {
        return NULL;
    }
    if(left<=right)
    {
        int mid=left+(right-left)/2;
        if(a[mid]>key)
        {
            return BinarySearch_R(a,n,key,left,mid-1);
        }
        else if(a[mid]<key)
        {
            return BinarySearch_R(a,n,key,mid+1,right);
        }
        else
        {
            return a+mid;
        }
    }
    else
    {
        return NULL;
    }
}

void testBinary_R()
{
	int a[10]={0,1,3,5,45,78,98,111,121,454};
	for (int i=9;i>=0;i--)
	{
		int *temp=BinarySearch_CR(a,10,i,0,9);
		if(temp==NULL)
		{
			cout<<"NULL"<<endl;
		}
		else
			cout<<*temp<<endl;
	}
}

题目:

正整数数组a[0], a[1], a[2], ···, a[n-1],n可以很大,大到1000000000以上,但是数组中每个数都不超过100。现在要你求所有数的和。假设这些数已经全部读入内存,因而不用考虑读取的时间。希望你用最快的方法得到答案。

提示:二分。

时间: 2024-10-06 03:36:54

有关二分查找的边界思考的相关文章

二分查找之再思考

一.一般的二分查找 一般的二分查找即,输出要查找元素在数组中的位置,这里的位置没有特殊限定,没有要求是数字第一次出现的位置,也没有要求是最后一次出现的位置. int getPos(vector<int> A, int n, int val) { if (A.size()==0) { return NULL; } int low=0; int high=n-1; while(low<=high) //注意这里是小于等于 { if (A[(low+high)/2]>val) { hig

二分查找技巧---字节跳动2018校招算法方向(第二批)---用户喜好

[编程题]用户喜好 时间限制:3秒 空间限制:262144K 为了不断优化推荐效果,今日头条每天要存储和处理海量数据.假设有这样一种场景:我们对用户按照它们的注册时间先后来标号,对于一类文章,每个用户都有不同的喜好值,我们会想知道某一段时间内注册的用户(标号相连的一批用户)中,有多少用户对这类文章喜好值为k.因为一些特殊的原因,不会出现一个查询的用户区间完全覆盖另一个查询的用户区间(不存在L1<=L2<=R2<=R1). 输入描述: 输入: 第1行为n代表用户的个数 第2行为n个整数,第

关于二分查找及其上下界问题的一些思考

个人认为在编程的时候,我的代码能力应该是到位的,但是昨天参加的某公司笔试彻底把这个想法给终结了,才意识到自己是多么的弱.其中印象最深刻的是一道关于二分查找上下界的问题.当时洋洋得意,STL 分分钟搞定,结果到了面试的时候他要我自己重新实现一下.这个时候就拙计了,拿着笔的我是写了改改了写,最后勉强算是完成. 今天反思一下,决定自己再把二分查找重新实现一下.也作为给自己的一个警醒,不要总以为自己能力有多高,总有一天会被打脸的. 一.二分查找思想(参照<算法竞赛入门经典>,感谢刘老师). 在有序表中

用C语言实现二分查找算法

二分查找算法思想非常简单,就是折半查找一个有序序列,在这里,我用二分查找一个顺序排列的整形数组.若用C实现的话我们需要注意以下几个方面: 1.如何判断查找完成,定义返回值含义,定义退出循环条件 2.如何处理边界问题,例如1 2 3 这个序列,当我们要查找1或者3时,会不会使程序出现BUG 3.对于数列来说,我们通常用整形存储其下标,二分查找若取下标中间数,则会出现什么样的问题?这些问题是否会影响我们的查找,若有问题,则应该如何规避? 通常情况,作为一个初学者,我甚至觉得二分查找过于简单,不值一提

细说“二分查找”

前言: 二分算法很常见,也很简单.但确实很高效!有了它,我们常常可以避免"暴力"! ------------------------------------------------- 1.二分漏洞 先贴一段代码,大家看看有没有问题? 1 int binarySearch(int *arr,int l,int r,int key){ 2 while(l<r){ 3 int m=(l+r)/2; 4 if(arr[m]==key){ 5 return m; 6 }else if(ar

二分查找总结

最近刷leetcode和lintcode,做到二分查找的部分,发现其实这种类型的题目很有规律,题目大致的分为以下几类: 1.最基础的二分查找题目,在一个有序的数组当中查找某个数,如果找到,则返回这个数在数组中的下标,如果没有找到就返回-1或者是它将会被按顺序插入的位置.这种题目继续进阶一下就是在有序数组中查找元素的上下限.继续做可以求两个区间的交集. 2.旋转数组问题,就是将一个有序数组进行旋转,然后在数组中查找某个值,其中分为数组中有重复元素和没有重复元素两种情况. 3.在杨氏矩阵中利用二分查

二分查找如何“花式”卖萌

二分查找,敢说这货埋在土里化到灰里应该都是认得的.其原理思想也是如此的简单明了,敲代码时都懒得经过反射弧.但事实上,据Knuth神犇描述,第一个木有bug的二分查找是这个算法发表之后12年在出现,但后来发现还是存在一些数组越界的小问题.而如今,我们大都是开门见山的学习被前辈们优化证明的算法,这也是“牛逼顿”所谓的站在巨人的肩膀上,却也如此. 回头来看二分查找如何“花式”卖萌. Problem:给定一个有序数组A,且数组中的元素存在重复,各大一个目标值target,求目标值在数组的的下标的区间(即

STL 二分查找三兄弟(lower_bound(),upper_bound(),binary_search())

一:起因 (1)STL中关于二分查找的函数有三个:lower_bound .upper_bound .binary_search  -- 这三个函数都运用于有序区间(当然这也是运用二分查找 的前提),下面记录一下这两个函数: (2)ForwardIter lower_bound(ForwardIter first, ForwardIter last,const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于等于值val的位置: (3)ForwardIter up

二分查找算法

提到查找算法,最经典的就是二分查找算法了.在二分查找时要在有序的数据里查找目标target,先取中间元素与target比较, 当target小于中间元素的时候,则搜索数组的前半部分,target大于中间元素时,则取数组的后半部分.重复整个搜索的过程 将左半部分与有半部分当作子数组继续查找,直到找到元素或到子数组的大小为0停止. 原理上很简单却有较多细节,尤其是数据边界的取值是否会越界,while循环的条件. java code: public class BinarySearchDemo { p