C++折半查找法

Posted 2023-03-23

#include <iostream>
using namespace std;
int main( )

int a[15]=20,19,16,15,14,13,12,10,9,7,6,5,3,2,1;
int max,min,mid,x,i,n;
min=1,max=20,mid=20;n=0;
cout<<"please input a number: ";
cin>>x;
for(;min<=max;)

if(x==mid)

for(i=0;i<15;i++)
if(a[i]>x) n=n+1;
cout<<"此数为第 "<<n+1<<"个元素的值"<<endl;break;
mid=(min+max)/2;
if(x<mid) max=mid-1;
if (x>mid) min=mid+1;
if (x!=mid) cout<<"无此数"<<endl;
return 0;

这个是我码的，不过似乎有个BUG，就是输入4、8、11等之内的数时还是显示有此数而且有说第几个，是他后面的那个数。比如11就是显示第8个，而第8个数其实是10……
怎么改……

折半查找法是算法一种，可以被任何计算机语言使用。用C语言自然也可以实现。

1、定义：

在计算机科学中，折半搜索（英语：half-interval search），也称二分搜索（英语：binary search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

2、查找规则：

折半查找法是效率较高的一种查找方法。假设有已经按照从小到大的顺序排列好的五个整数a0~a4，要查找的数是X，其基本思想是： 设查找数据的范围下限为l=0，上限为h=4，求中点m=（l+h）/2，用X与中点元素am比较，若X等于am，即找到，停止查找；否则，若X大于am，替换下限l=m+1，到下半段继续查找；若X小于am，换上限h=m-1，到上半段继续查找；如此重复前面的过程直到找到或者l>h为止。如果l>h，说明没有此数，打印找不到信息，程序结束。

3、C语言参考代码：

int bin_search(int A[],int n,int key)
//在长度为n的数组A 中折半查找值为key的元素，并返回下标值。如果不存在则返回-1.
    int low,high,mid;
    low = 0;
    high = n-1;//初始low和high为数组的两端。
    while(low<=high)
    
        mid =(low + high)/2;//查找中心点。
        if(A[mid]==key)return mid;//已找到，返回下标值。
        if(A[mid]<key)//中点位置比key值小，以mid+1为新的下限值。
            low =mid + 1;
        
        if(A[mid]>key)//中点位置比key值大，以mid-1为新的上限值。
            high= mid - 1;
        
    
    return -1;//未找到，返回-1.
参考技术A

你对对半查找理解错了，你的min,max应该是下标而不是值

原理：类似于二分法解方程，二分查找首先比对序列中间的数是否是要找的数，如果不是，由于是有序数列，则看其在左侧区间还是右侧区间，舍弃不在的那一半区间，然后在剩余的区间重复刚才的办法，直到找到该数，由于每次舍弃一半的数据量，所以查找效率较高。

描述：设三个变量 left,right,middle分别为序列的两侧下标和中间下标，当判断出不在左侧区间，则 left=middle+1 ，从而利用右侧一半构造出一个新区间，否则 right=middle-1，利用左边一侧构造新区间，然后重复刚才过程，如此下去，要么找到数据，要么left>right，此时也应该停止查找，说明序列中没有该数。

const int N=10;
 int left,right,middle,x;
 int a[N]=2,5,6,8,9,12,24,32,38,40;
cout << "输入个要查找的数： ";
 cin>>x;
 for (left=0,right=N-1;left<=right;)

    middle=(left+right)/2;
    if (x==a[middle])
        break;
    else if (x<a[middle])
        right=middle-1;
    else
        left=middle+1;

 if (x==a[middle])
    cout<<"a["<<middle<<"]="<<x<<endl;
 else
    cout<<"查找不到"<<x<<endl;

本回答被提问者和网友采纳 参考技术B if (x=a[i]) /* 应该是x==a[i]吧 */

用递归实现，程序会很好理解
int f(int a[],int x, int start,int end)

int i=start+(end-start)/2;
if(start>end) return -1;/* 没找到，返回-1 */
if(a[i]==x) return i;
else if(a[i]>x) return f(a,x,i+1,end);
else return f(a,x,start,i-1);

--------------------------------------------------------------------------
修改如下：
#include<stdio.h>
void main()

int a[15],x,i,start,end;
printf("input 15 numbers:\n");
for(i=0;i<15;i++) scanf("%d",&a[i]);
printf("please enter the number:\n");
scanf("%d",&x);
for(start=0,end=14;start<=end;)

i=start+(end-start)/2;
if (x==a[i])

printf("%d",i+1);
getch();
return;

else if (x>a[i]) end = i-1;
else start=i+1;

参考技术C

亲，你对折半查找的理解完全错误了。

min 和 max 不是指 容器中的最大元素 和最小元素，指的是元素在容器中的位置。

折半查找，仅仅要求容器内元素是 有序的就ok了。

我替你码的代码

#include <iostream>
void main()
    int a[]=20,19,16,15,14,13,12,10,9,7,6,5,3,2,1;
    const int size = sizeof(a) / sizeof(int);
    int x;
    std::cout << "please input a number: ";
    std::cin >> x;
    int low = 0, high = size - 1;
    int mid;
    bool found = false;
    while (low <= high)
        mid = (low + high) / 2;
        if (a[mid] > x)
            high = mid - 1;
         else if (a[mid] < x)
            low = mid + 1;
         else
            found = true;
            break;
        
    
    if (found)
        std::cout << "at " << mid << std::endl;
     else
        std::cout << "not found!" << std::endl;
    

参考技术D 首先，应当声明两个变量来记录这般查找空间的范围，这里我们定义begin和end；其次判断语句if(x=a[i])中x=a[i]是赋值语句，"=="是判断相等运算符，应该为if(x == a[i]);最后，主函数为int型，应最后返回0表示运行成功，即在程序结尾家return 0;

以下是我在你代码基础上略加修改，已通过运行并成功。
#include<stdio.h>
int main()

int a[15],x,y,i;
printf("input 15 numbers:\n");
for(i=0;i<15;i++)
scanf("%d",&a[i]);
printf("please enter the number:\n");
scanf("%d",&x);
int begin = 0, end = 14;
while(begin <= end)

i = (begin + end) / 2;
if (x==a[i])

y=i+1;
printf("%d",y);
break;

else
if (x>a[i])
end = i - 1;
else
begin = i + 1;

return 0;

数据结构50：二分查找法(折半查找法)

折半查找，也称二分查找，在某些情况下相比于顺序查找，使用折半查找算法的效率更高。但是该算法的使用的前提是静态查找表中的数据必须是有序的。

例如，在{5,21,13,19,37,75,56,64,88 ,80,92}这个查找表使用折半查找算法查找数据之前，需要首先对该表中的数据按照所查的关键字进行排序：{5,13,19,21,37,56,64,75,80,88,92}。

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

折半查找算法

对静态查找表{5,13,19,21,37,56,64,75,80,88,92}采用折半查找算法查找关键字为 21 的过程为：

图 1 折半查找的过程（a）

如上图 1 所示，指针 low 和 high 分别指向查找表的第一个关键字和最后一个关键字，指针 mid 指向处于 low 和 high 指针中间位置的关键字。在查找的过程中每次都同 mid 指向的关键字进行比较，由于整个表中的数据是有序的，因此在比较之后就可以知道要查找的关键字的大致位置。

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

因此，再次遍历时需要更新 high 指针和 mid 指针的位置，令 high 指针移动到 mid 指针的左侧一个位置上，同时令 mid 重新指向 low 指针和 high 指针的中间位置。如图 2 所示：

图 2 折半查找的过程（b）
 

同样，用 21 同 mid 指针指向的 19 作比较，19 < 21，所以可以判定 21 如果存在，肯定处于 mid 和 high 指向的区域中。所以令 low 指向 mid 右侧一个位置上，同时更新 mid 的位置。

图 3 折半查找的过程（3）

当第三次做判断时，发现 mid 就是关键字 21 ，查找结束。

注意：在做查找的过程中，如果 low 指针和 high 指针的中间位置在计算时位于两个关键字中间，即求得 mid 的位置不是整数，需要统一做取整操作。

折半查找的实现代码：

#include <stdio.h>
#include <stdlib.h>
#define keyType int

typedef struct 
{
    keyType key;　　// 查找表中每个数据元素的值
    // 如果需要，还可以添加其他属性
}ElemType;

typedef struct
{
    ElemType *elem;　　// 存放查找表中数据元素的数组
    int length;　　　　 // 记录查找表中数据的总数量
}SSTable;

// 创建查找表
void Create(SSTable **st, int length)
{
    (*st) = (SSTable*)malloc(sizeof(SSTable));
    (*st)->length = length;
    printf("输入表中的数据元素：\n");
    // 根据查找表中数据元素的总长度，在存储时，从数组下标为 1 的空间开始存储数据
    for (int i=1; i<=length; i++) 
　　 {
        scanf("%d", &((*st)->elem[i].key));
    }
}

//折半查找算法
int Search_Bin(SSTable *ST, keyType key)
{
    int low = 1;　　//初始状态 low 指针指向第一个关键字
    int high = ST->length;　　//high 指向最后一个关键字
    int mid;
    while (low <= high) 
　　{
        mid = (low+high) / 2;　　// int 本身为整形，所以，mid 每次为取整的整数
        if (ST->elem[mid].key == key)　　// 如果 mid 指向的同要查找的相等，返回 mid 所指向的位置
        {
            return mid;
        }
　　　　 else if(ST->elem[mid].key > key)　　// 如果mid指向的关键字较大，则更新 high 指针的位置
        {
            high = mid-1;
        }
        // 反之，则更新 low 指针的位置
        else
　　    {
            low = mid + 1;
       }
    }

    return 0;
}

int main(int argc, const char * argv[]) 
{
    SSTable *st;
    Create(&st, 11);
    getchar();
    printf("请输入查找数据的关键字：\n");
    int key;
    scanf("%d", &key);
    int location = Search_Bin(st, key);
    //如果返回值为 0，则证明查找表中未查到 key 值，
    if (location == 0) 
　　 {
        printf("查找表中无该元素");
    }
　　 else
　　 {
        printf("数据在查找表中的位置为：%d", location);
    }
    return 0;
}

以图 1 的查找表为例，运行结果为：
输入表中的数据元素：
5 13 19 21 37 56 64 75 80 88 92
请输入查找数据的关键字：
21
数据在查找表中的位置为：4

 

折半查找的性能分析

折半查找的运行过程可以用二叉树来描述，这棵树通常称为“判定树”。例如图 1 中的静态查找表中做折半查找的过程，对应的判定树如图 4：

图 4 折半查找对应的判定树

在判定树中可以看到，如果想在查找表中查找 21 的位置，只需要进行 3 次比较，依次和 56、19、21 进行比较，而比较的次数恰好是该关键字所在判定树中的层次（关键字 21 在判定树中的第 3 层）。

对于具有 n 个结点（查找表中含有 n 个关键字）的判定树，它的层次数至多为：log2n + 1（如果结果不是整数，则做取整操作，例如： log211 +1 = 3 + 1 = 4 ）。

同时，在查找表中各个关键字被查找概率相同的情况下，折半查找的平均查找长度为：ASL = log2(n+1) – 1。

总结

通过比较折半查找的平均查找长度，同前面介绍的顺序查找相对比，明显折半查找的效率要高。但是折半查找算法只适用于有序表，同时仅限于查找表用顺序存储结构表示。

当查找表使用链式存储结构表示时，折半查找算法无法有效地进行比较操作（排序和查找操作的实现都异常繁琐）。