精华内容
下载资源
问答
  • 17.【 STEMA】以下关于二分查找算法的描述中,不正确的是(A) A二分查找算法的最大查找时间与查找对象的大小成正比 B二分查找一般从数组的中间元素开始 C二分查找只对有序数组有效 D二分查找可以使用递归实现 ...

    17.【 STEMA】以下关于二分查找算法的描述中,不正确的是(A)
    A二分查找算法的最大查找时间与查找对象的大小成正比
    B二分查找一般从数组的中间元素开始
    C二分查找只对有序数组有效
    D二分查找可以使用递归实现

    展开全文
  • 分治法——二分查找

    千次阅读 2017-11-04 19:27:35
    二分查找又称为折半查找,它要求待查找的数据元素必须是按关键字大小有序排列的。问题描述:给定已排好序的n个元素s1,…,sn,现要在这n个元素中找出一特定元素x。 首先较容易想到使用顺序查找方法,逐个比较s1,…,sn...

    问题描述:

    二分查找又称为折半查找,它要求待查找的数据元素必须是按关键字大小有序排列的。问题描述:给定已排好序的n个元素s1,…,sn,现要在这n个元素中找出一特定元素x。

    首先较容易想到使用顺序查找方法,逐个比较s1,…,sn,直至找出元素x或搜索遍整个序列后确定x不在其中。显然,该方法没有很好地利用n个元素已排好序这个条件。因此,在最坏情况下,顺序查找方法需要O(n)次比较。

    算法思想:

    假定元素序列已经由小到大排好序,将有序序列分成规模大致相等的两部分,然后取中间元素与特定查找元素x进行比较,如果x等于中间元素,则算法终止;如果x小于中间元素,则在序列的左半部继续查找,即在序列的左半部重复分解和治理操作;否则,在序列的右半部继续查找,即在序列的右半部重复分解和治理操作。可见,二分查找算法重复利用了元素间的次序关系。

    算法设计:

    步骤1:确定合适的数据结构。设置数组s[n]来存放n个已排好序的元素;变量low和high表示查找范围在数组中的下界和上界;middle表示查找范围的中间位置;x为特定元素;

    步骤2:初始化。令low=0;high=n-1;

    步骤3:middle=(low+high)/2,即指示中间元素;

    步骤4:判定low小于等于high是否成立,如果成立,转步骤5;否则,算法结束;

    步骤5:判断x与s[middle]的关系。如果x==s[middle],算法结束;如果x>s[middle],则令low=middle+1;否则令high=middle-1,转步骤3。

    实例:

    图片1
    图片2
    图片3
    图片4

    算法分析:

    设给定的有序序列中具有n个元素。

    显然,当n=1时,查找一个元素需要常量时间,因而T(n)=O(1)。

    当n>1时,计算序列的中间位置及进行元素的比较,需要常量时间O(1)。递归地求解规模为n/2的子问题,所需时间为T(n/2)。

    因此,二分查找算法所需的运行时间T(n)的递归形式为:

    当n>1时,T(n)=T(n/2)+O(1)

                          =……

                         =T(n/2x)+xO(1)

    简单起见,令n=2x,则x=logn。

    由此,T(n)=T(1)+logn=O(1)+O(logn)。因此,二分查找算法的时间复杂性为O(logn)

    代码实现:

    #include <iostream>
    
    using namespace std;
    
    int NBinarySearch(int n,int s[],int x);
    int BinarySearch(int s[],int x,int low,int high);
    
    int main()
    {
        int n,x;
        cout<<"输入元素个数: ";
        cin>>n;
        int s[n];
        cout<<"按从小到大的顺序输入数组元素"<<endl;
        for(int i=0; i<n; i++)
        {
            cin>>s[i];
        }
        cout<<"输入要查找的数字"<<endl;
        cin>>x;
    
        int m1 = NBinarySearch(n,s,x);
        int m2 = BinarySearch(s,x,0,n-1);
        if(m1>=0)
        {
            cout<<"非递归:你要查找的数字为: s["<<m1<<"]."<<endl;
        }
        else
        {
            cout<<"非递归:你要查找的数字不存在"<<endl;
        }
    
        if(m2>=0)
        {
            cout<<"递归:你要查找的数字为: s["<<m2<<"]."<<endl;
        }
        else
        {
            cout<<"递归:你要查找的数字不存在"<<endl;
        }
        return 0;
    }
    
    int NBinarySearch(int n,int s[],int x)
    {
        int low=0,high=n-1;
        while(low<=high)
        {
            int middle=(low+high)/2;
            if(x==s[middle])  return middle;
            else if(x>s[middle]) low=middle+1;
            else high=middle-1;
        }
        return -1;
    }
    
    int BinarySearch(int s[],int x,int low,int high)
    {
        if (low>high) return -1;
        int middle=(low+high)/2;
        if(x==s[middle])  return middle;
        else if(x>s[middle])
            return BinarySearch (s, x, middle+1, high);
        else
            return BinarySearch (s, x, low, middle-1);
    }
    

    测试:

    测试截图

    展开全文
  • 二分查找】详细图解

    万次阅读 多人点赞 2021-04-24 15:59:45
    二分查找 文章目录二分查找1. 简介2. 例子3. 第一种写法(左闭右闭)3.1 正向写法(正确演示)3.2 反向写法(错误演示)4. 第二种写法(左闭右开)4.1 正向写法(正确演示)4.2 反向写法(错误演示)5. 总结 写在前面...

    在这里插入图片描述

    二分查找

    写在前面:

    (一)二分法的思想十分容易理解,但是二分法边界处理问题大多数人都是记忆模板,忘记模板后处理边界就一团乱(👁:“我懂了”, ✋ :"你懂个🔨"​)因为我此前也是记忆模板,所以现在想通过一边学习,一边将所学记录成博客教出去(费曼学习法),希望以后能自己推导出边界如何处理,而不仅仅是记忆模板。欢迎一起交流学习,如有看法不一样之处也欢迎留言一起讨论!

    (二)我主要解释了二分法的左闭右闭区间,左闭右开区间两种写法,并且每个写法都举了相应的反例,范围写错的话可能会出现的错误等…

    1. 简介

    故事分享🏬:

    有一天小明到图书馆借了 N 本书,出图书馆的时候,警报响了,于是保安把小明拦下,要检查一下哪本书没有登记出借。小明正准备把每一本书在报警器下过一下,以找出引发警报的书,但是保安露出不屑的眼神:你连二分查找都不会吗?于是保安把书分成两堆,让第一堆过一下报警器,报警器响;于是再把这堆书分成两堆…… 最终,检测了 logN 次之后,保安成功的找到了那本引起警报的书,露出了得意和嘲讽的笑容。于是小明背着剩下的书走了。 从此,图书馆丢了 N - 1 本书。

    保安怎么知道只有一本书📖没有登记出借,万一全部都没有登记呢​?

    这个故事其实说出了二分查找需要的条件

    • 用于查找的内容逻辑上来说是需要有序的
    • 查找的数量只能是一个,而不是多个

    比如在一个有序的数组并且无重复元素的数组中,例如[1, 2, 3, 4, 5, 6],需要查找3的位置就可以使用二分查找。

    在二分查找中,目标元素的查找区间的定义十分重要,不同的区间的定义写法不一样

    因为查找的区间是不断迭代的,所以确定查找的范围十分重要,主要就是左右区间的开和闭的问题,开闭不一样,对应的迭代方式也不一样,有以下两种方式:

    • 左闭右闭[left, right]

    • 左闭右开[left, right)

    2. 例子

    这是一个使用二分查找的例题

    题目如下:

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

    示例一:

    输入: nums = [-1,0,3,5,9,12], target = 9
    输出: 4
    解释: 9 出现在 nums 中并且下标为 4

    示例二:

    输入: nums = [-1,0,3,5,9,12], target = 2
    输出: -1
    解释: 2 不存在 nums 中因此返回 -1

    提示:

    • 你可以假设 nums 中的所有元素是不重复的。
    • n 将在 [1, 10000]之间。
    • nums 的每个元素都将在 [-9999, 9999]之间。

    出自704. 二分查找 - 力扣(LeetCode) (leetcode-cn.com)

    二分法的思想很简单,因为整个数组是有序的,数组默认是递增的。

    • 首先选择数组中间的数字和需要查找的目标值比较
    • 如果相等最好,就可以直接返回答案了
    • 如果不相等
      • 如果中间的数字大于目标值,则中间数字向右所有数字都大于目标值,全部排除
      • 如果中间的数字小于目标值,则中间数字向左所有数字都小于目标值,全部排除

    二分法就是按照这种方式进行快速排除查找的

    tips:

    不用去纠结数组的长度是奇数或者偶数的时候,怎么取长度的一半,以下说明,可以跳过。

    当数组的长度为奇数的时候

    是奇数的情况很简单,指向中间的数字很容易理解,如果需要查找的数字为29

    因为29大于中间的数字大于11,所以左边的所有数字全部排除

    当数组的长度为偶数的时候

    这个时候中间的数字两边的数字数量就不一样了(刚开始学习二分法的时候我经常纠结这个问题,和另外一个长度除2得到的是最中间的数吗的问题,我相信不止我一个人纠结过……但其实这是同一个问题,每次长度除2,如果长度为奇数,得到的中间的数字两边数字数量相同,如果长度为偶数就为上图中间的数字两边的相差为 1)

    但是千万不要一直纠结中间的数字两边的数字数量不一样这个问题,因为:

    • 两边数量不一样是一定会出现的情况
    • 但是这种情况并不影响我们对中间数字和目标数字大小关系的判断
      • 只要中间数字大于目标数字,就排除右边的
      • 只要中间数字小于目标数字,就排除左边的

    所以数组长度是偶数还是奇数这个真的不重要,不影响怎么排除的问题,无非是多排除一个数字或者少排除一个数字

    • 真正影响的是中间那个数字到底该不该加入下一次的查找中,也就是边界问题

    3. 第一种写法(左闭右闭)

    二分法最重要的两个点:

    • while循环中 left 和 right 的关系,到底是 left <= right 还是 left < right
    • 迭代过程中 middle 和 right 的关系,到底是 right = middle - 1 还是 right = middle

    3.1 正向写法(正确演示)

    第一种写法:每次查找的区间在[left, right](左闭右闭区间),根据查找区间的定义(左闭右闭区间),就决定了后续的代码应该怎么写才能对。因为定义 target 在[left, right]区间,所以有如下两点:

    • 循环条件要使用while(left <= right),因为当(left == right)这种情况发生的时候,得到的结果是有意义的
    • if(nums[middle] > target) , right 要赋值为 middle - 1, 因为当前的 nums[middle] 一定不是 target ,需要把这个 middle 位置上面的数字丢弃,那么接下来需要查找范围就是[left, middle - 1]

    代码如下:

    int search(int nums[], int size, int target) //nums是数组,size是数组的大小,target是需要查找的值
    {
        int left = 0;
        int right = size - 1;	// 定义了target在左闭右闭的区间内,[left, right]
        while (left <= right) {	//当left == right时,区间[left, right]仍然有效
            int middle = left + ((right - left) / 2);//等同于 (left + right) / 2,防止溢出
            if (nums[middle] > target) {
                right = middle - 1;	//target在左区间,所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1;	//target在右区间,所以[middle + 1, right]
            } else {	//既不在左边,也不在右边,那就是找到答案了
                return middle;
            }
        }
        //没有找到目标值
        return -1;
    }
    

    下面图解算法的实现过程,建议将代码复制到一个文本编辑器中,边看代码边看图。或者我直接准备了图片,保存下来打开看就好了。

    首先看一个数组,需要对这个数组进行操作。需要对33进行查找的操作,那么target 的值就是33

    • 首先,对 left 的值和 right 的值进行初始化,然后计算 middle 的值
      • left = 0, right = size - 1
      • middle = (left + (right - left) / 2 )
    • 比较 nums[middle] 的值和 target 的值大小关系

      • if (nums[middle] > target),代表middle向右所有的数字大于target
      • if (nums[middle] < target),代表middle向左所有的数字小于target
      • 既不大于也不小于就是找到了相等的值
    • nums[middle] = 13 < target = 33,left = middle + 1

    • 见下图:

    • 循环条件为 while (left <= right)

    • 此时,left = 6 <= right = 11,则继续进行循环

    • 当前,middle = left + ((right - left) / 2),计算出 middle 的值

    • 计算出 middle 的值后,比较 nums[middle] 和 target 的值,发现:

      • nums[middle] = 33 == target = 33,找到目标

    3.2 反向写法(错误演示)

    对应第一种正向的写法,我们把循环条件修改看看会发生什么事

    • 原查找区间 [left, right]
    • 原循环条件是 while (left <= right)

    修改后题目对应的条件:

    • 查找区间不变,仍然是[left, right]
    • 查找数字为27 (target = 27)
    • 循环条件修改为while (left < left)

    代码:

    int search(int nums[], int size, int target) 
    {
        int left = 0;
        int right = size - 1;	
        while (left < right) {	//left <= right 修改为 left < right,其他不变
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else if (nums[middle] < target) {
                left = middle + 1;
            } else {	
                return middle;
            }
        }
        //没有找到目标值
        return -1;
    }
    

    代码图片,边看模拟过程边看代码哦!

    好了,现在开始用图片模拟过程

    • 初始化一个数组,计算 middle 的值
    • 根据计算的 middle 值确定 nums[middle]
    • 因为nums[middle] = 13 < target = 27,所以left = middle + 1
    • 继续计算 middle 的值
    • 因为 nums[middle] = 33 > target = 27,所以 right = middle - 1
    • 接着计算 middle 的值
    • 因为 nums[middle] = 22 < target = 27,此时 left = middle + 1,此时 left = right,而循环条件为while (left < right),所以还未找到27 的情况下算法就跳出了循环,返回 -1

    4. 第二种写法(左闭右开)

    4.1 正向写法(正确演示)

    第二种写法:每次查找的区间在 [left, right),(左闭右开区间), 根据区间的定义,条件控制应该如下:

    • 循环条件使用while (left < right)
    • if (nums[middle] > target), right = middle,因为当前的 nums[middle] 是大于 target 的,不符合条件,不能取到 middle,并且区间的定义是 [left, right),刚好区间上的定义就取不到 right, 所以 right 赋值为 middle。

    代码如下:

    int search(int nums[], int size, int target)
    {
    	int left = 0;
    	int right = size; //定义target在左闭右开的区间里,即[left, right)
    	while (left < right) {	//因为left = right的时候,在[left, right)区间上无意义
    		int middle = left + ((right - left) / 2);
    		if (nums[middle] > target) {
    			right = middle; //target 在左区间,在[left, middle)中 
    		} else if (nums[middle] < target) {
    			left = middle + 1;
    		} else {
    			return middle;
    		}
    	} 
        // 没找到就返回-1
    	return -1;
    }
    

    代码图片:保存下来边看代码边看图片演示过程

    • 需要查找的值为3

    第一步是初始化 left 和 right 的值,然后计算 middle 的值

    • left = 0, right = size
    • 循环条件while (left < right)

    因为是左闭右开区间,所以数组定义如下:

    • 计算 middle 的值,
    • 比较 nums[middle] 和 target 的大小:因为 nums[middle] = 22 > target = 3
    • 所以 right = middle
    • 符合循环的条件,接着计算 middle 的值
    • 比较 nums[middle] 和 target 的大小:因为 nums[middle] = 9 > target = 3
    • 所以 right = middle
    • 符合循环的条件,继续计算 middle 的值
    • 比较 nums[middle] 和 target 的大小关系:因为nums[middle] = 0 < target = 3
    • 所以 left = middle + 1

    在这里插入图片描述

    • 符合循环条件,接着计算 middle 的值
    • 比较 nums[middle] 和 target 的关系:nums[middle] = 3 == target = 3
    • 成功找到 target

    4.2 反向写法(错误演示)

    对应第二种正确的写法,照样把循环条件修改,看会发生什么事

    正确的写法中条件为:

    • 查找原区间 [left, right)
    • 循环条件为 while (left < right)

    修改后题目对应的条件:

    • 查找区间不变,仍然是 [left, right)

    • 循环条件修改为:while (left <= right)

    • 查找的数字为26(数组中不存在这个数字!!!

    代码:

    int search(int nums[], int size, int target)
    {
    	int left = 0;
    	int right = size; 
    	while (left <= right) {	//条件left < right 修改为 left <= right
    		int middle = left + ((right - left) / 2);
    		if (nums[middle] > target) {
    			right = middle; 
    		} else if (nums[middle] < target) {
    			left = middle + 1;
    		} else {
    			return middle;
    		}
    	} 
        // 没找到就返回-1
    	return -1;
    }
    

    代码图片:(记得边看边保存图片代码边看图片演示哦!)

    以下是演示全过程:

    • 同样,开始初始化一个数组
    • 先计算 middle 的值
    • 判断 nums[middle] 和 target 的大小关系:nums[middle] = 22 < target = 26
    • left = middle + 1 (其实这里nums[left] 已经等于27,26不可能找到,接下去就看算法是否能够知道数组中不存在26并且返回-1 了)
    • 符合循环条件,计算 middle 的值
    • 判断 nums[middle] 和 target 的大小关系:nums[middle] = 57 > target = 26
    • right = middle
    • 满足循环条件,接着计算 middle 的值
    • 比较 nums[middle] 和 target 的大小关系:nums[middle] = 33 > target = 26
    • right = middle
    • 符合循环条件,继续计算 middle 的值
    • 比较 nums[middle] 和 target 大小关系,因为 nums[middle] = 27 > target = 26,
    • 所以 right = middle,自此,left 和 right 相遇,但是循环条件被我们修改成 while (left <= right) 会接着做循环
    • 接下来就是死循环

    • 因为 middle = left + ((right - left) / 2),当 left = right 的时候,middle 的值不会继续改变

    • middle 不继续改变,由于right = middle,right 也不会改变,所以三个数字自此开始不会继续改变

    • 循环条件 while (left <= right) 却仍然满足,不会跳出循环

    • 死循环……

    5. 总结

    二分法最重要的两个点,就是循环条件和后续的区间赋值问题

    因为两者是相互联系,相互影响的,所以就需要两者统一,如果两者不统一,就会出现问题

    所以循环条件和赋值问题必须统一,也就是循环不变量。

    相关题目推荐:

    本文相关信息:

    • 算法学习自微信公众号:“代码随想录”
    • 画图软件:Diagrams
    • 代码生成图片软件:Carbon

    ❤️完结撒花❤️

    展开全文
  • 此处很明显应该借用二分查找的思想,但是有几个细节还是值得注意。 先修知识点: 二分查找的非递归写法 为叙述清晰,下文一律使用“线程栈“指代每个线程拥有的栈空间,用”栈“来指代数据结构意义上的栈。使用...

    找出有序数组绝对值最小元素

    题目要求: 给定一个有序整数数组,返回其中绝对值最小的元素。
    例如数组【-5,2,0,1,3】则返回 0

    此处很明显应该借用二分查找的思想,但是有几个细节还是值得注意。

    • 先修知识点:
      • 二分查找的非递归写法
        • 为叙述清晰,下文一律使用“线程栈“指代每个线程拥有的栈空间,用”栈“来指代数据结构意义上的栈。使用“堆”指代一个进程的堆空间。
        • 非递归实现的好处: 递归算法在递归深度过深时,会发生占“线程栈”溢出, 因为每一次函数调用都会占用更多的“线程栈”空间, 而每个线程拥有的栈空间是独立的,而且大小是预分配好的。
        • 非递归写法常常通过使用“栈”来保存递归调用中需要记录的信息,这部分空间可以来源于“堆”空间。 一个进程的多个线程会共享堆空间,通常堆空间相比线程栈的空间要大,且可以动态增加,因此更不容易发生溢出。

    二分查找的非递归写法

    非递归
    # here the parameter n is the length of array
    binary_search(int[] a, int n, int value)
    {
        int left = 0
        int right = n-1
    
        while( left< = right) //易错
        {
               middle = left + (right - left)/ 2 
    
               ifa[middle] > value)
               {
                    right = middle -1 //易错
               }
               else if ( a[middle] < value)
               {
                    left = middle +1  //易错
                }
                else
                {
                    return middle   
                }
        }
        return -1
    }
    • 二分查找法的思想很简单,唯一需要主义的就是几个易错的点
      • 第8行whil循环条件是 left <= right 不是left < right
      • 第13行right = middle -1
      • 第21行left = middle -1

    二分查找之最小绝对值查找

    int absMin(int* array, int size)
    {
        if(size == 1)
            return a[0];
        if(a[0] * a[size-1] >= 0)  //如果同符号,这里用乘法判断正负有可能发生溢出,为书写简便,在此不作修正
            return (a[0] >= 0) ? a[0] : a[size-1];
        else
        {
            int low = 0, high = size-1, mid;
            while(low < high) //易错
            {
                if(a[middle]==0) 
                    return middle;  
                    //此处不加也可以让后续的部分正确运行,但是加上可以减少无谓的对比。如果不加的话,遇到数组中间元素为0的情况,会一直循环到left和right相邻,且其中有一个位置的元素为0
                if(low + 1 == high)
                    return abs(a[low]) < abs(a[high]) ? a[low] : a[high];
                mid = low + (high - low) / 2;
                if(a[low] * a[mid] >= 0) 
                    low = mid;  //易错,
                if(a[high] * a[mid] >= 0)
                    high = mid; //易错
            }
        }
    }
    
    • 首先给定的数组有序, 因此先检查首位元素是否同符号,如果同符号, 则绝对值最小元素可以立刻给出(同正则为第一个元素, 同负则为最后一个元素)
    • 当数组不同符号时,运用二分查找的思想, 首先计算middle = (left + right)/2
      • 此处要注意与二分查找相似而不同的地方:
        • 得到middle后,需要判断middle是否为0
          • 如果为0, 则可以直接返回该元素位置作为绝对值最小的元素
          • 如果该位置不为0, 则判断其正负, 如果为正,则需检查middle-left是否大于1,因为middle-left = 1的情况是找到了该数组正负变化的边界, 需要比较边界处两个元素哪个绝对值比较小。 例如【-5.-3.-2.-1,2,4,6】,最终比较的应该是-1与2的绝对值大小
        • 尤其和二分查找不同的是, 循环中,由于每一次的middle都有可能是正负边界的元素,所以每一次循环中,left = middle 或 left = right 而不是 left = middle+1 或 right = middle - 1
    展开全文
  • 数据结构中简单的二分查找(折半查找)流程图实例
  • 文章目录标准的左开右闭区间二分查找典型的错误范例左闭右开区间好在哪里?二分查找算法的逐句分析二分查找的其他写法 最近做了不少算法题,二分查找对于有序数组题目的应用非常多。而自己二分查找实际上只做到了背...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    5. 下面关于算法说法错误的是(D )【南京理工大学 2000 一、1(1.5)】 A.算法最终必须由计算机程序实现 B.为解决某问题的算法同为该问题编写的程序含义是相同的 C. 算法的可行性是指指令不能有义性 D. ...
  • 力扣---寻找两个有序数组的中位数,下面看一下题目 题目叙述 给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。 请你找出这两个有序数组的中位数,并且要求算法的时间复杂度为 O(log(m + n))。 你可以假设 nums1...
  •   二分查找的思想和套路已经了然于心了,但是还是有些问题解决不了?这个时候就可能需要多见一些特殊的用例了。这一次再来一种二分查找的特例。 题目描述 峰值元素是指其值大于左右相邻值的元素。 给定一个输入...
  • 第九章 查找 一 选择题 若查找每个记录的... 下面关于二分查找叙述正确的是 ( ) A. 表必须有序 表可以顺序方式存储 也可以链表方式存储 C. 表必须有序 而且只 能从小到大排列 B. 表必须有序且表中数据必须是整型 实
  • 二分查找七种情况大合集,核心不变 二分查找,其实是非常简单的算法,却令自己非常容易晕头转向。早该抽取时间好好推一推,怪自己太懒。今年市赛有题卡了2小时,就是因为二分写不出。写出来样例都对,却无限WA,找...
  • 在我们的编程学习中,遇到了一些问题需要将一个大规模的问题分解成几个较小规模的问题,通过对较小规模问题的求解达到对整个问题的解,这种方法叫做分治法,而在分治法中又衍生出来了一个小方法,叫做二分查找,相信...
  • 数据结构方法之二分查找

    万次阅读 2012-10-13 12:40:32
    一、什么是二分查找法?(略) 二、二分查找法的性能分析。 二分查找法的平均查找长度是ASL=log2(n+1)-1 (n>50) ★例题: 对长度为12的有序表(a1,a2,...a12)(其中ai当i时),进行折半查找,在假 定查找不成功时,...
  • 分治法-二分查找(c语言描述)

    千次阅读 2010-11-14 11:52:00
    递归的解这些子问题,然后将各子问题的解合并得到原问题的解,二分查找是分治策略的一个典型例子,分置策略的典型例子还有就是合并排序(在排序算法里有合并排序的c语言描述),下面给出二分查找的代码:  ...
  • 集合

    千次阅读 多人点赞 2019-04-28 20:25:50
    集合1 集合概念2 集合特点3 集合的功能4 集合的遍历5 1 集合概念 2 集合特点 3 集合的功能 集合的增删查包含 集合的增加 void add(); //添加一个元素 void addAll();//相当于把两个集合合并成一个集合 ...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    也可以两步创建Person类的对象:Person OnePerson;OnePerson=new Person();OnePerson虽然存储的是Person类对象地址,但不是C中的指针,不能象指针那样可以进行加减运算,也不能转换为其它类型地址,它是引用型...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    <br>实验 单链表结构及计算 实验目的: 通过实验掌握下列知识: 1、熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现; 2、继续熟悉VC编程、编译和调试环境; 内容及步骤:...
  • maven

    千次阅读 多人点赞 2018-07-11 16:03:00
    Maven的核心功能便是合理叙述项目间的依赖关系,通俗点讲,就是通过pom.xml文件的配置获取jar包,而不用手动去添加jar包 什么是maven项目 包含pom.xml的项目就是maven项目。 maven项目...
  • 数据结构之二分查找

    千次阅读 2012-11-26 20:54:09
    一、什么是二分查找法?(略) 二、二分查找法的性能分析。 二分查找法的平均查找长度是ASL=log2(n+1)-1 (n>50) ★例题: 对长度为12的有序表(a1,a2,...a12)(其中ai当i时),进行折半查找,在假 定查找不成功时,...
  • 《数据结构》-第七章 查找(习题)

    千次阅读 2021-08-27 22:39:13
    关于查找的不同算法为每年考试考查的重点,因此需要重点把握各个结构包括的查找方法及查找删除等操作的过程。对散列结构主要,应学握散列表的构造、冲突处理方法(各种方法的处理过程)、查找成功和查找失败的平均查找...
  • 数据结构面试题

    千次阅读 多人点赞 2018-01-22 10:21:28
    的结点),并且,二叉树的子树有左右之,其次序不能任意颠倒。 7.1.2 二叉树的基本性质 ①在二叉树的第 I 层上至多有 2i-1 个结点。 ②深度为 k 的二叉树至多有 2k-1 个结点 (k>=1) ③在任意...
  • linux命令大全

    千次阅读 2015-12-24 08:44:14
    Linux命令大全完整版 目 录 目 录... I 1. linux系统管理命令... 1 adduser1 chfn(change finger information)1 chsh(change shell)1 date. ...gitps(gnu interactive tools proce
  • verilog 综合注意事项

    万次阅读 多人点赞 2016-07-29 15:46:40
    则执行下面的语句块,"always"有点象C语言中的"if ... then...","wait"和"@"的区别:请参考本模块.wait表示本语句块的进程停止,直到"cdn=0"的条件出现才继续;我理解在verilog中,每个最外层语句块都是一个***的进程;...
  • 分布式服务框架

    千次阅读 2016-01-29 10:42:11
    memcache 存储支持的数据格式也是灵活多样的,通过对象的序列化机制,可以将更高层抽象的对象转换成为进制数据,存储在缓存服务器中,当前端应用需要时,又可以通过进制内容反序列化,将数据还原成原有对象。...
  • 二分思想与分治法、排序思想二分查找是《编程珠玑》作者很喜爱的一个话题,之前我曾经专门写了一篇博文:如何写出正确的二分查找?——利用循环不变式理解二分查找及其变体的正确性以及构造方式,在这里将换几个角度...
  • 冒泡 选择 快序 二分查找 网上答案: 排序的方法有:插入排序(直接插入排序、希尔排序), 交换排序(冒泡排序、快速排序), 选择排序(直接选择排序、堆排序), 归并排序,分配排序(箱排序、基数排序)...
  • 二分答案详解

    千次阅读 2018-04-25 13:04:30
    题目背景 一年一度的“跳石头”比赛又要开始了! 题目描述 这项比赛将在一条笔直的河道中进行,河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛...简单说后者是利用了二分的思想,前者则是二分查找的模板
  • chap8 查找(单选题)

    千次阅读 2019-12-08 01:17:08
    若采用二分查找法查找一个L中不存在的元素,则关键字的比较次数最多是: (2分) 4 5 6 7 2-2 用二分查找从100个有序整数中查找某数,最坏情况下需要比较的次数是:(2分) 7 10 50 99 2-3 在有n(n>1000)...
  • 查找习题

    千次阅读 2018-06-03 14:53:17
    (1.4.3.1)查找练习题2015年04月17日 18:52:56阅读数:1976一、 选择题1.若查找每个记录的概率均等,则在具有n个记录的连续顺序文件中采用顺序查找查找一个记录,其平均查找长度ASL为( C )。 A. (n-1)/2 B...
  • 《图书管理系统》毕业论文

    万次阅读 多人点赞 2008-11-24 11:13:00
    在前面的几章的例子中已经详细介绍了关于如何定制具有标准查询并修改功能的表单, 其实 Visual FoxPro6.0 本身也具有生成具有上述功能表单的功能。下面就介绍如何通过表单向导完成读者种类管理表单的设计,设计的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,276
精华内容 6,910
关键字:

下面关于二分查找的叙述