二分查找 (折半查找)

二分查找又称折半查找,它是一种效率较高的查找方法。
【二分查找要求】:1.必须采用顺序存储结构          2.必须按关键字大小有序排列。
【优缺点】折半查找法的优点是比较次数少,查找速度快,平均性能好;
             其缺点是要求待查表为有序表,且插入删除困难。 因此,折半查找方法适用于 不经常变动而 查找频繁的有序列表。

【算法思想】首先,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;
                              否则利用中间位置记录将表分成前、后两个子表, 如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。
重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

【算法复杂度】假设其数组长度为n,其算法复杂度为o(log(n))

#include <stdio.h> //二分查找:
int search(int a[],int x,int n) //x为要查找的元素,n为数组长度
{
int mid=0; int low=0; int high=n;
while (low<=high)
{
mid=(low+high)/2;
if (a[mid]==x) return mid;

else if (x<a[mid]) return high=mid-1;

else return low=mid+1 ; 
}
return -1;
}

int main()
{
int i,a[10],x;
for (i=0;i<10;i++)
scanf("%d",&a[i]);

printf("请输入要查找的元素 ");
scanf("%d",&x);

if (search(a,x,10)!=-1) 
printf("查找的元素在数组中的位置为%d.\n",search(a,x,10));
else printf("该元素不在数组中\n");
return 0;
}

#include <stdio.h>
void fsort(int a[], int i,int num);
main()
{    int a[4]={2,10,19,25};
    int num;
    printf("请输入要查找的号码:");
    scanf("%d",&num);//二分法 a[]为数组,n为数组大小,num为要查找的数字
    fsort(a,4,num);
}
void fsort(int a[],int n,int num)
{
    int high,low,mid;
   int flag = 1;
    high=n-1;      low=0;
    while (low<=high)
    {
        mid = (high+low)/2;
        if (a[mid]<num)           {      low = mid+1;   }
        else if (a[mid]>num)      {      high = mid -1; }
        else
        {
            printf("位置在第%d位:",mid+1);
            printf("%d\n",a[mid]);
            flag = 0;
            break;
        }
    }
     if (flag)   {        printf("无此数字");}
}

#include <stdio.h>
int main ( )
{
int a[10]={ 0,4,5,6,13,27,50,90,100,999} ;
int low ,high,mid, x ;
printf("\n 输入待查的元素:");
scanf("%d",&x);

low=0 ; high=9 ;
while(low<=high)
{
mid=(low+high)/2 ;
if(a[mid]==x) 
       {     printf("%d 的位置(下标)是:%d\n",x,mid);      break;    }

if(a[mid]<x)    low=mid+1 ;
else              high=mid-1;

}

if(low>high) printf("%d不存在\n",x) ;

}

查到了,输出元素下标 ; 没查到,返回-1

法一

#include <stdio.h>
#define N 10
int f(int a[],int low,int high,int x)
{
         int mid ;
     while (low<=high)
       {
            mid=(low+high)/2 ;
                    if (a[mid]==x)                    return        mid ;
                   else    if (a[mid]<x)              return    f(a,mid+1,high,x) ;
                   else                                    return     f(a,low,mid-1,x);
}
return -1 ;
}
int main ( )
{

int x, a[N]={ -1,12,23,42,56,65,81,92,100,109} ;
scanf("%d",&x);

printf("%d\n",f(a,0,N-1,x));

}

法二

#include <stdio.h>
#define N 6
int f(int a[],int low,int high,int x)
{
               int mid =(low+high)/2 ;

if (low>high)                               return  -1 ;

else         if (a[mid]==x)              return   mid ;
else        if (a[mid]>x )                return     f(a,low,mid-1,x);
else                                           return      f(a,mid+1, high,x);

}
int main ( )
{

int x, a[N]={ 1,2,3,5,6,7} ;
scanf("%d",&x);
printf("%d\n",f(a,0,N-1,x));

}

二分查找 (折半查找)

时间: 2024-10-09 04:44:34

二分查找 (折半查找)的相关文章

二分查找/折半查找算法

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

(java)有序表查找——折半查找,插值查找,斐波那契查找

有序表查找 /* 主函数 */ public class OrderTableSearch { public static void main(String[] args) { int [] a= {0,1,16,24,35,47,59,62,73,88,99}; System.out.println(FibonacciSearch(a, 10, 88)); System.out.println(InsertKeySearch(a, 10, 88)); System.out.println(Bi

顺序查找,折半查找,二叉排序树的建立,哈希表的建立

以下四个验证性实验都做. (1)顺序查找验证 (2)折半查找验证 (3)二叉排序树的建立 (4)哈希表的建立 #include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> #include<string.h> #include<algorithm> using namespace std; class dijiuzhang { public: int a[1

二分查找/折半查找

二分查找又叫折半查找. 前提:数组是有序的. 思想:1.每次都拿中间的数的key进行比较,如果相等,找到: 2.如果key > 中间数,说明key在中间数的右边,接着拿右边的中间数和key比较: 3.如果key < 中间数,说明key在中间数的左边,接着拿左边的中间数和key比较: 4.循环上述过程: 啥也不说了,上代码: 1 #include <stdio.h> 2 3 int main(int argc, const char * argv[]) { 4 5 // 定义数组 6

java 二分查找 - 折半查找算法

二分查找: 这个算法是比较简单的,容易理解的.这个算法是对有序的数组进行查找,所以想要使用这个算法那么 首先先要对数组进行排序. 其实有三个指针,开始指针,末尾指针,中间指针,来开始.折半查找. 步骤如下: 1.确定三个指针,start,end,middleIndex. 2.判断start<=end,如果满足,就执行这个方法,不满足,就返回,找不到. 3.在2的前提下,我们对其折半查找,middleIndex = start+end >> 1,取中间值. 4.判断中间位置的值和目标值是否

Java 实现二分查找\折半查找

二分查找又称折半查找,优点是比较次数少,查找速度快:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表. 该算法要求: 1.  必须采用顺序存储结构. 2.  必须按关键字大小有序排列. 该算法时间复杂度最坏为:O(logn) 注意点有mid.low.high 其Java实现代码如下(该代码有缺陷,只是基本实现,有待完善): public class BinarySearch { /** * @param args */ public static

二分法查找(折半查找)

顺序查找并没有对表中的关键字域的顺序做出任何假设,与顺序查找不同,在折半查找中,表中的记录是按关键字域有序排列的,其比较会出现下面三种结果: searchumn< list[middle].key,此时,无需考虑位于list[middle]和list[n-1]之间的记录,而继续查找位于list[0]和list[middle-1]间的记录. searchnum=list[middle].key,此时,查找成功,结束查找. searchnum>list[middle].key,此时,无需考虑位于l

二分查找/折半查找(C++实现)

要求:给定已按升序排好序的n个元素a[0:n-1],现要在这n个元素中找出一特定元素x. 分析: 该问题的规模缩小到一定的程度就可以容易地解决: 如果n=1即只有一个元素,则只要比较这个元素和x就可以确定x是否在表中.因此这个问题满足分治法的第一个适用条件 该问题可以分解为若干个规模较小的相同问题; 分解出的子问题的解可以合并为原问题的解: 分解出的各个子问题是相互独立的. 比较x和a的中间元素a[mid], 若x=a[mid],则x在L中的位置就是mid: 如果x<a[mid],则x在a[mi

有序查找——折半查找

1 public static String binarySearch(int[] a, int num) { 2 if (a.length == 0) 3 return "Eroor"; 4 int start = 0; 5 int end = a.length - 1; 6 int mid = (start + end) / 2; 7 while (start <= end) { 8 if (num == a[mid]) { 9 return "所查数在数组的下标为

01. Java的经典排序--选择排序--冒泡排序--折半查找(二分查找)

Java的经典排序--选择排序--冒泡排序--折半查找 选择排序 选择排序 3 2 1 5 8 0 1 3 2 5 8 1 1 2 3 5 8 2 1 2 3 5 8 3 1 2 3 5 8 public static void main(String[] args) { int[] arr={3,2,1,5,8}; selectSort(arr); for(int i = 0 ; i < arr.length ; i ++){ System.out.println(arr[i]) ; } }