精华内容
下载资源
问答
  • 有一个数组 v 已经按升序...解决这个问题的一个普遍方法是折半查找。下面是程序:#include int binsearch(int x, int v[], int n);main(){int i, result, n;int wait;int x = 17;// 需要查找的数值int v[19]; // ...

    有一个数组 v 已经按升序排列了,数组 v 有 n=20 个元素。数组中有个元素 x,如何知道 x 位于该数组的第几位呢?

    解决这个问题的一个普遍方法是折半查找。下面是程序:

    #include

    int binsearch(int x, int v[], int n);

    main()

    {

    int i, result, n;

    int wait;

    int x = 17;// 需要查找的数值

    int v[19]; // 定义一个数组

    // 给数组赋值

    for(i = 0; i < 20; ++i)

    v[i] = i;

    /**

    for(i = 0; i < 20; ++i)

    printf("%d \n", v[i]);

    */

    n = 20;

    result = binsearch(x, v, n);

    printf("%d", result);

    scanf("%d", &wait);

    }

    int binsearch(int x, int v[], int n)

    {

    int low, high, mid;

    low = 0;

    high = n - 1;

    while (low <= high)

    {

    mid = (low + high) / 2;

    if(x < v[mid])

    high = mid - 1;

    else if (x > v[mid])

    low = mid + 1;

    else

    return mid;

    // 看看循环执行了多少次

    printf("mid = %d, low = %d, high = %d \n", mid, low, high);

    }

    return -1;

    }

    思路很简单:首先将输入值 x 与数组 v 的中间元素比较,如果 x 小于中间的元素,则将 high 值设为 中间元素-1,同理,若 x 大于中间元素,则将中间元素 + 1作为 low,再在low 与 high之间进行查找。

    展开全文
  • 折半查找实例

    2018-10-17 21:26:16
    该程序是一个折半查找的一个具体的例子,其中有对数组的冒泡排序,以及随机数组的产生。
  • 文章目录查找查找的概念顺序查找顺序查找-算法原理顺序查找-算法实现顺序查找-性能分析折半查找折半查找-算法原理折半查找-算法实现折半查找-性能分析分块查找分块查找-算法原理分块查找-算法实现分块查找-性能分析 ...

    查找

    ​ 查找是在查询数据过程中必不可少的一个环节,那么如何来进行查找,以及如何进行高效率的查找,就是接下来要解决的问题。

    查找的概念

    ​ 首先提出一些定义,在查找元素的时候,必然是从一堆数据中去找自己想要的数据,那么这种由同一类型的数据元素构成的集合就被称为查找表。对于查找表可执行以下操作:

    1. 查询某个“特定的”数据元素是否在查找表中;
    2. 检索某个“特定的”数据元素的各种属性;
    3. 在查找表中插入一个数据元素;
    4. 从查找表中删去某个数据元素

    根据查找表的操作方式来分类,可以将查找表分为两类:静态查找表和动态查找表。

    1. 静态查找表:仅作查询和检索的查找表。
    2. 动态查找表:在查找过程中同时插入查找表中不存在的数据元素,或者从查找表中删除已存在的某个数据元素

    在数据表中,应该用一个东西来标识每一个数据元素用以识别该数据,这个东西就叫做关键字,关键字是数据元素(或记录)中某个数据项的值,用以标识(识别)一个数据元素(或记录)。其中关键字也可以进行细分:

    1. 主关键字:可以识别唯一的一个记录的关键字
    2. 次关键字:能识别若干记录的关键字

    关于关键字这里可以简单举个例子,以全校成绩为例,学号就是每个学生的主关键字,因为一个学号唯一识别一个学生,学院就是次关键字,学院可以识别若干个学生,但是不能唯一识别一个学生。

    ​ 那么查找是一个什么过程呢,查找就是根据给定的值,在查找表中确定一个其关键字等于给定值的数据元素那么根据查询结果来看分为查询成功和查询不成功,查找成功就是在查找表中查找到指定的记录;查找不成功就是在查找表中没有找到指定记录。

    ​ 最后还有很关键的一点,就是如何衡量一个查找算法的效率。这里主要参考以下几点:

    1. 时间复杂度
    2. 空间复杂度
    3. 平均查找长度 A S L ASL ASL

    这里重点讲一下什么是平均查找长度 A S L ASL ASL,平定义为确定记录在表中的位置所进行的和关键字比较的次数的平均值,可以使用下面的公式来表示。
    A S L = ∑ i = 1 n P i C i ASL=\sum_{i=1}^n{P_iC_i} ASL=i=1nPiCi
    其中, n n n为查找表的长度,即表中所含元素。 P i P_i Pi为查找第 i i i哥元素的概率( ∑ P i = 1 \sum{P_i=1} Pi=1)。 C i C_i Ci是查找第 i i i个元素时同给定值 K K K比较的次数。

    顺序查找

    ​ 顺序查找算法是查找算法中最简单直接的一种方法,它是属于静态查找表中的一种查找方法。

    顺序查找-算法原理

    ​ 顺序查找有两种实现方式,第一种就是平时常用的那种,从数组的第一个元素开始往后遍历,直到遍历到数组的最后一个元素或者说找到对应的元素才停止。

    ​ 对于第一种方式,在查找的时候还需要考虑数组是否会越界的问题,那么为了解决这个问题,就采用哨兵的方式来进行查找。一般情况将数组的第一个元素当作哨兵,放置待查询关键字,然后从数组的最后一个元素开始往前查找,这样一来就不用考虑越界的情况,因为数组的第一个元素一定会等于最后一个元素。
    在这里插入图片描述

    在这里插入图片描述

    顺序查找-算法实现

    ​ 对于第一种方法,直接采用最简单的 f o r for for循环从第一个遍历到最后一个即可,代码如下所示。

    // 顺序查找,不带哨兵
    int Sequential_Search(int data[], int n, int key)
    {
    	// 通过for循环查找即可
    	for (int i = 1; i <= n; i++)
    	{
    		// 如果相等则返回下标
    		if (data[i] == key)
    			return i;
    	}
    	// 没有找到返回0
    	return 0;
    }
    

    ​ 对于第二种哨兵法,整体思路和前面相同,都是通过遍历的方法来进行查找,但是减少了数组越界的判断。

    // 顺序查找,带哨兵
    int Sequential_Search2(int data[], int n, int key)
    {
    	data[0] = key;	// 第一个位置当作哨兵
    	int index = n;	// 从后往前进行查找
    	// 此处省略对数组越界的判断,因为data[0] = key
    	while (data[index] != key)
    	{
    		index--;
    	}
    	return index;
    }
    

    顺序查找-性能分析

    ​ 对于顺序表而言, C i = n − i + 1 C_i=n-i+1 Ci=ni+1,同时假设是等概率查找,即 P i = 1 n P_i=\frac{1}{n} Pi=n1,故可以计算得到该顺序表的平均查找长度为
    A S L = n P 1 + . . . + P n = n ( n + 1 ) 2 ASL=nP_1+...+P_n=\frac{n\left( n+1 \right)}{2} ASL=nP1+...+Pn=2n(n+1)
    ​ 同时顺序查找的优点在于其简单且适应面广(对表没有额外要求),但是缺点也很明显,平均查找长度较大,尤其是当 n n n很大时,查找效率很低。

    折半查找

    ​ 在平常查找过程中,例如在图书馆找某本书,如果图书馆中的书已经按照书名的首字母拼写摆放好了,那么就可以根据这些顺序来更加快速的找到想要的书籍,而折半查找就是源于这一思想,同时折半查找也是静态查找表中的查找方法。

    折半查找-算法原理

    ​ 首先需要声明的是,折半查找算法是有序表的查找方法,这也就代表在折半查找算法中,静态查找表按关键字大小的次序,有序地存放在顺序表中。

    ​ 在有序表中,可以通过不断缩小区间的方法来确定要查找的元素的位置,原理类似于数学中的牛顿二分法。每次查找时根据区间的上下界,计算出一个中点值,该中点值的关键字如果大于查找的关键字,则取后半部分区间继续查找,反之则取前半部分区间继续查找,直到找到该记录或区间无法再缩小为止(找不到)。

    ​ 接下来查看一个查找成功的例子。
    在这里插入图片描述

    ​ 以及一个查找不成功的例子。
    在这里插入图片描述

    折半查找-算法实现

    ​ 具体到代码实现时,只需要将上述步骤设计成流程即可,如下所示。

    1. n n n个对象从小到大存放在有序顺序表 S T ST ST中, k k k为给定值
    2. l o w low low h i g h high high指向待查元素所在区间的下界、上界,即 l o w = 1 , h i g h = n low=1, high=n low=1,high=n
    3. m i d mid mid指向待区间的中点,即 m i d = ( l o w + h i g h ) / 2 mid=(low+high)/2 mid=(low+high)/2
    4. k k k m i d mid mid指向的记录比较
      k = S T [ m i d ] . k e y k=ST[mid].key k=ST[mid].key,查找成功
      k < S T [ m i d ] . k e y k<ST[mid].key k<ST[mid].key,则 h i g h = m i d − 1 high=mid-1 high=mid1 [上半区间]
      k > S T [ m i d ] . k e y k>ST[mid].key k>ST[mid].key,则 l o w = m i d + 1 low=mid+1 low=mid+1 [下半区间]
    5. 重复3,4操作,直至low>high时,查找失败。
    // 折半查找
    int Binary_Search(int data[], int n, int key)
    {
    	int low = 1;	// 低位
    	int high = n;	// 高位
    	while (low <= high)	// 不断缩小区间
    	{
    		int mid = (low + high) / 2;	// 中值
    		if (data[mid] > key)	// 如果中值大于关键字,则下一次从[low, mid-1]中找
    			high = mid - 1;
    		else if (data[mid] < key)	// 如果中值小于关键字,则下一次从[mid+1,high]中找
    			low = mid + 1;
    		else	// 成功找到则直接返回
    			return mid;
    	}
    	// 没有找到返回0
    	return 0;
    }
    

    折半查找-性能分析

    ​ 在分析折半查找的平均查找长度时,需要借助到二叉树来进行分析,由于每次都是折半的过程,那么就可以将原来的有序序列看做成一个二叉树(中序遍历为有序结果),如下所示。
    在这里插入图片描述

    ​ 在具体到查找时,也是按照上述顺序逐层进行查找,因为有 n n n个结点的上述二叉树深度为 [ log ⁡ 2 n ] + 1 [\log _{2}^{n}]+1 [log2n]+1,故折半查找法在查找过程中比较次数不超过 [ log ⁡ 2 n ] + 1 [\log _{2}^{n}]+1 [log2n]+1次。上述二叉树也被称为判定树。

    ​ 设有序表的长度 n = 2 h − 1 n=2^h-1 n=2h1,则描述折半查找的判定树是深度为 h h h的满二叉树。树中层次为1的结点有1个,层次为 h h h的结点有 2 h − 1 2^{h-1} 2h1个。

    ​ 假设表中每个记录的查找概率相等,则查找成功时折半查找的平均查找长度为
    A S L = 1 n ∑ i = 1 n C i = 1 n [ ∑ j = 1 h j ⋅ 2 j − 1 ] = n + 1 n ASL=\frac{1}{n}\sum_{i=1}^n{C_i=}\frac{1}{n}\left[ \sum_{j=1}^h{j\cdot 2^{j-1}} \right] =\frac{n+1}{n} ASL=n1i=1nCi=n1[j=1hj2j1]=nn+1
    ​ 折半查找的优点在于相比于顺序查找,其查找效率很高,特别是在静态查找表的长度很长时,但是缺点也很明显,那就是只能适用于有序表,且数据需要以顺序存储结构存储。

    分块查找

    ​ 分块查找是一种索引顺序表查找方法,是折半查找和顺序查找的简单结合。索引顺序表是将整个表分成几块,块内无序,块间有序,这两个要求的含义具体如下所示。

    1. 块内无序:同一块内的记录不要求有序。
    2. 块间有序:后一块中所有记录的关键字均大于前一块中所有记录的最大关键字。

    分块查找-算法原理

    ​ 那么对于索引顺序表(分块有序表)可以将其分为两个表,第一个表就是主表,用数组存放待查记录,每个数据元素至少含有关键字域;第二个就是索引表,每个结点含有最大关键字域和只想本快第一个结点的指针,如下所示。
    在这里插入图片描述

    ​ 那么在查找某个元素时,首先通过折半查找的方法来索引块中找到该元素所属的块,之后再通过顺序查找的方式在该块中找到对应的元素。
    在这里插入图片描述

    分块查找-算法实现

    ​ 分块查找主要就是折半查找和顺序查找的合并版,实现起来没有问题,重点在于如何建立索引表。这里的前提是已经分好了块,但是需要去标注每个块的起始下标,直接通过遍历主表元素即可,从第一个块的最大元素比较起,遇到的第一个比第一个块最大元素还大的元素,就是第二个块的起始元素,以此类推。

    // 创建索引表
    void Create_Index(int data[], int n, int index[], int indexOrder[])
    {
    	/// <summary>
    	/// 创建索引表
    	/// </summary>
    	/// <param name="data">查找表</param>
    	/// <param name="n">查找表长度</param>
    	/// <param name="index">每个块的最大数据</param>
    	/// <param name="indexOrder">每个块的起始下标</param>
    
    	int pos = 1;	// 数据从1开始
    	indexOrder[pos++] = 1;	// 第一组起点为1
    	for (int i = 1; i <= n; i++)	// 遍历所有数据
    	{
    		if (data[i] > index[pos - 1])	// 遇到第一个比前一个块最大数据大的
    		{
    			indexOrder[pos++] = i;	// 说明该点是一个新块的起点
    		}
    	}
    }
    

    ​ 这里为了简单起见,块的查找和块内查找都是使用了顺序查找进行实现,代码如下所示。

    // 分块索引查找
    int Index_Search(int data[], int n, int index[], int k, int indexOrder[], int key)
    {
    	/// <summary>
    	/// 分块索引查找
    	/// </summary>
    	/// <param name="data">查找表</param>
    	/// <param name="n">查找表长度</param>
    	/// <param name="index">每个块的最大数据</param>
    	/// <param name="k">块的个数</param>
    	/// <param name="indexOrder">每个块的起始下标</param>
    	/// <param name="key">待查找的关键字</param>
    	/// <returns></returns>
    
    	// 先找数据所属的块
    	int part = 1;	// 从第一块开始查找
    	int begin = 0;	// 数据所属块的起始下标
    	for (int i = 1; i <= k; i++)	// 逐块查找
    	{
    		// 如果当前块最大数据大于带查找关键字
    		// 则说明关键字就在该块中
    		if (index[i] >= key)	
    		{
    			part = i;
    			begin = indexOrder[i];
    			break;
    		}
    	}
    	int end = n;	// 初始化块的尾地址
    	if (part < k)	// 判断是否是最后一个块
    		end = indexOrder[part + 1] - 1;
    
    	// 顺序查找
    	for (int i = begin; i <= end; i++)
    	{
    		if (data[i] == key)
    			return i;
    	}
    	return 0;
    }
    

    分块查找-性能分析

    ​ 对于分块查找,设若将长度为 n n n的表分成 b b b块,每块含 s s s个记录,并设表中每个记录查找概率相等。

    ​ 用折半查找方法在索引表中查找索引块
    A S L 块间 ≈ l o g 2 n s + 1 ASL_{\text{块间}}\approx log_{2}^{\frac{\mathrm{n}}{\mathrm{s}+1}} ASL块间log2s+1n

    ​ 用顺序查找方法在主表对应块中查找记录
    A S L 块内 ≈ s 2 ASL_{\text{块内}}\approx \frac{\mathrm{s}}{2} ASL块内2s
    ​ 故总的平均查找长度为
    A S L ≈ l o g 2 n s + 1 + s 2 ASL\approx log_{2}^{\frac{\mathrm{n}}{\mathrm{s}+1}}+\frac{\mathrm{s}}{2} ASLlog2s+1n+2s

    展开全文
  • 折半查找漏数据的例子,仅供学习参考 create procedure fTheLossNo @cardno as begin declare @maxBalance float,@minBalance float,@middleBalance float,@tempMaxBalance float,@tempMinBalance float set @...
  • 折半查找 c语言函数

    2009-02-01 17:55:27
    折半查找c语言函数, 在数组总查找 例子
  • 折半查找

    2016-11-10 22:04:31
    折半查找也叫二分查找,是很快的查找方式,使用普遍,前提是数据先进行排序,比如以下例子中用到的数组就是拍好序的int arr[]={1,2,3,4,5,6,7,8,9,10}; #include using namespace std; int binSearch(int x,...

    折半查找也叫二分查找,是很快的查找方式,使用普遍,前提是数据先进行排序,比如以下例子中用到的数组就是拍好序的int arr[]={1,2,3,4,5,6,7,8,9,10};

    #include <iostream>

    using namespace std;
    int binSearch(int x,int a[],int n);
    void main()
    {
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int num;
    num=9;
    int result;
    result=binSearch(num,arr,10);
    if(result>=0)
    {
    printf("在arr[%d]中找到%d\n",result,num);
    cout<<"在arr["<<result<<"]中找到"<<num<<endl;//c++输出格式
    }

    }
    int binSearch(int x,int a[],int n)
    {
    int low ,high,mid;
    low=0;
    high=n-1;

    while(low<=high)
    {
    mid=(low+high)/2;
    if(x<a[mid])
    {
    high=mid-1;
    }
    else if(x>a[mid])
    {
    low=mid+1;
    }
    else
    return mid;
    }
    return -1;
    }
    展开全文
  • 折半查找

    千次阅读 2019-04-12 20:29:46
    折半查找   折半查找,也称二分查找,在某些情况下相比于顺序查找,使用折半查找算法的效率更高。但是该算法的使用的前提是静态查找表中的数据必须是有序的。例如,在{2,10,16,19,23,44,56,58,69,80,99} 这个查找...

    折半查找


      折半查找,也称二分查找,在某些情况下相比于顺序查找,使用折半查找算法的效率更高。但是该算法的使用的前提是静态查找表中的数据必须是有序的。例如,在{2,10,16,19,23,44,56,58,69,80,99} 这个查找表使用折半查找算法查找数据之前,需要首先对该表中的数据按照所查的关键字(从小到大)进行排序:{2,10,16,19,23,44,56,58,69,80,99}。

      在折半查找之前对查找表按照所查的关键字进行排序的意思是:若查找表中存储的数据元素含有多个关键字时,使用哪种关键字做折半查找,就需要提前以该关键字对所有数据进行排序。

      折半查找算法----->对静态查找表{2,10,16,19,23,44,56,58,69,80,99}查找关键字为 19 的过程为:
    这里写图片描述为
           在这里插入图片描述
      如上图 所示,指针 low 和 high 分别指向查找表的第一个关键字和最后一个关键字,指针 mid 指向处于 low 和 high 指针中间位置的关键字。在查找的过程中每次都同 mid 指向的关键字进行比较,由于整个表中的数据是有序的,因此在比较之后就可以知道要查找的关键字的大致位置。

      例如在查找关键字 19 时,首先同 44 作比较,由于19 < 44,而且这个查找表是按照升序进行排序的,所以可以判定如果静态查找表中有 16这个关键字,就一定存在于 low 和 mid 指向的区域中间。

      因此,再次遍历时需要更新 high 指针和 mid 指针的位置,令 high 指针移动到 mid 指针的左侧一个位置上,同时令 mid 重新指向 low 指针和 high 指针的中间位置。如图所示:
    这里写图片描述
           在这里插入图片描述
      同样,用 19 同 mid 指针指向的 16 作比较,19 > 16,所以可以判定 19 如果存在,肯定处于 mid 和 high 指向的区域中。所以令 low 指向 mid 右侧一个位置上,同时更新 mid 的位置。
    这里写图片描述
            在这里插入图片描述
      当第三次做判断时,发现 mid 就是关键字19 ,查找结束。
    注意:在做查找的过程中,如果 low 指针和 high 指针的中间位置在计算时位于两个关键字中间,即求得 mid 的位置不是整数,需要统一做取整操作。
    简化的例子,找8,并输出下标。代码为:

    #include <stdio.h>
    #include <stdlib.h>
    
    //折半查找,又称为二分查找 ,条件保证要好排序的,不适合应用在频繁的插入操作,因为会打乱顺序
    int Binary_Search(int *a,int n,int key)
    {
        int low,high,mid;
        low = 0;    //定义最低下标为记录首位
        high = n;   //记录最高下标为记录末位
    
        while ( low <= high )
        {
            mid = (low + high) / 2;
            if (key < a[mid]) {
                high = mid - 1;//最高位下标调小 一位
            }
            else if(key > a[mid]){
                low = mid + 1; //最低下标调整到中位下标大一位
            } 
            else{
                return mid; //代表就是次位置
            }
        }
        return -1; //没有找到返回-1
    }
    
    void main()
    {
        int a[] = {1,2,3,4,5,6,7,8,9,10};
    
        //需求要查找8, 如果用传统的方式 要查找8次才能得出
        int index;//下标
        index = Binary_Search(a, sizeof(a) / sizeof(int),8);
    
        if (index == -1)
            printf("没有找到");
        else
            printf("找到了,index为:%d",index);
    }
    
    展开全文
  • 二分查找也常被称为二分法或者折半查找,每次查找时通过将待查找区间分成两部分并只取一部分继续查找,将查找的复杂度大大减少。对于一个长度为 O(n) 的数组,二分查找的时间复杂度为 O(log n)。
  • 折半查找算法

    千次阅读 2021-01-15 11:21:30
      答案:猜中间数 代码实现:      二分查找应用:  寻找一个数、寻找左侧边界、寻找右侧边界 1)代码框架:  二分查找法实质上是不断地将有序数据集进行对半分割,并检查每个分区的中间元素。时间复杂度为O...
  • 7.2.2折半查找

    2020-10-13 22:11:56
    类似于数学中二分法找零点 而且如果要求唯一零点可能严格要求单调函数这与折半查找只适用于有序表和他的算法思想不谋而合。 加油⛽️(∩ᄑ_ᄑ)⊃━☆爱情魔法ฅ( ˃̶˙ω˙˂̶ ฅ)拍拍我( ๑ˊ•̥▵•)੭₎₎...
  • 二分查找(折半查找),最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些. 顺序查找 /*顺序查找 顺序查找是在一个已知无(或有序)序队列中找出与给定关键字相同的 ... 自学Python3.6-算法 二分查找算法 ...
  • 程序员技术交流①群:736386324...在折半查找之前对查找表按照所查的关键字进行排序的意思是:若查找表中存储的数据元素含有多个关键字时,使用哪种关键字做折半查找,就需要提前以该关键字对所有数据进行排序。 ...
  • 文章目录一、顺序查找1.1 无序表的顺序查找1.2 有序表的顺序查找二、折半查找三、分块查找 一、顺序查找 顺序查找又称线性查找,主要用于在线性表中进行查找。 1.1 无序表的顺序查找 对无序线性表进行顺序查找,...
  • c++折半查找算法

    千次阅读 2018-10-24 11:20:38
    何谓折半查找,举个例子很快就可以明白,给你了9个数 1 2 3 4 5 6 7 8 9 让你去找2在哪里,这时候你肯定会说这太简单了,但是计算机就没那么强了,它得拿着2和这9个数一个一个的比较,2在前面还好比较的次数比较小,...
  • 查找算法之折半查找

    2013-03-17 21:19:54
     折半查找适用于在有序表中进行查找,先与有序表的中间元素进行比较,有三种情况:1)等与中间元素,则查找成功;2)小于中间元素,则继续在小数区间查找;3)大于中间元素,则继续在大数区间进行查找。 二、...
  • C++实现顺序查找,折半查找,插值查找 1.顺序查找 从数组起始扫描到数组结尾,判断该索引数组是否和关键字相等,成功返回1 代码如下: //顺序查找 int seqSearch(int *array, int low, int ...
  • 二分查找法(折半查找法)
  • 【数据结构】折半查找及其二叉判定树画法

    万次阅读 多人点赞 2019-09-25 23:55:40
    折半查找又叫二分查找,是数据结构中一种很重要的查找方式。 其特点有以下几个: 只能对有序的顺序表进行查找。 是一种静态查找。 查找的平均时间复杂度为o(log2n)。 成功平均查找长度ASL约log2(n+1)-1。 ...
  • 折半查找又叫二分查找,它的前提是线性表中的记录必须是关键码有序(通常是从小到大有序),线性表必须采用顺序存储。 /** * 折半查找,也叫二分查找,时间复杂度O(logn) */ public class BinarySearch { /** *...
  • C语言查找算法之顺序查找、二分查找(折半查找),最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些。 顺序查找 /*顺序查找 顺序查找是在一个已知无(或有序)序队列中找出与给定关键字相同的...
  • C语言折半查找DEMO

    2012-12-20 11:40:47
    【C语言折半查找】 #include #include int binserarch(int x,int v[],int n); int main(void) { int v[]={10,20,30,40,50,60}; /*由小到大排序好的数据*/ int x; /*存放要查找的数*/ int arr_size; in
  • 本文主要介绍了顺序查找、折半查找、静态最优查找树和索引顺序表查找等几种查找算法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,100
精华内容 2,840
关键字:

折半查找的例子