精华内容
下载资源
问答
  • 静态查找表。实现有序表折半查找算法 静态查找表。实现有序表折半查找算法 静态查找表。实现有序表折半查找算法静态查找表。实现有序表折半查找算法
  • 主要介绍了PHP有序表查找之二分查找(折半查找)算法,简单介绍了二分查找的概念、原理并结合实例形式分析了php基于二分查找算法进行有序线性表查找的相关操作技巧,需要的朋友可以参考下
  • 有序表查找---折半查找算法

    万次阅读 2019-03-10 20:00:31
    折半查找的基本思想是:在有序表中,取中间值为比较对象,如果给定的值和中间值的关键字相等,则查找成功;若给定值小于中间记录的关键字,则中间记录的左半区继续查找;若给定的值大于中间值的关键字,则中间...

    折半查找概念

    折半查找,又称二分查找。
    前提是线性表中的记录必须是关键码有序(由小到大或由大到小),线性表必须采用顺序存储。
    折半查找的基本思想是:在有序表中,取中间值为比较对象,如果给定的值和中间值的关键字相等,则查找成功;若给定值小于中间记录的关键字,则在中间记录的左半区继续查找;若给定的值大于中间值的关键字,则在中间记录的右半区继续查找。重复上述过程,直到查找成功,或查找所有区域无记录,返回查找失败。

    算法实现

    	public int Binary_Search(int[] a, int n, int key) {
    		int low = 1, high = n, mid;
    		while(low <= high) {
    			mid = (int)((low + high) / 2);
    			if(key < a[mid]) {
    				high = mid - 1;
    			}
    			else if(key > a[mid]) {
    				low = mid + 1;
    			}
    			else return mid;
    		}
    		
    		return 0;
    	}
    

    通常会使用三个指针low,high,mid。分别表示查找区域的最左值下标,查找区域的最右值下标,已经当前比对值下标。

    时间复杂度分析

    折半查找其实等于是把静态有序查找表分成了两棵子树,即查找经过只需要找其中的一半数据即可,等于工作量少了一半,以提升效率。
    完全二叉树存在定义:

    具有n个节点的我拿权二叉树深度为log2n + 1

    尽管折半查找判定二叉树并不是完全二叉树,但同样相同的推倒可以得到关键字或查找失败的次数是log2n + 1。最好为情况下查询次数为1。所有折半查找算法的时间复杂度为O(logn + 1)。

    缺点

    折半查找的前提是需要有序表顺序存储,对于静态查找表,一次排序后不再变化,但对于需要频繁执行插入或删除操作的数据集来说,维护有序的排序会带来不小的工作量,这个时候不建议使用。

    展开全文
  • 、解题思路 1.宏定义数组元素数为ARRNUM=10 函数原型声明void AscendSorting(int a[]); 函数原型声明int Bisearch(int x,int *a[],int left, int right); 2.设计函数 2.1设计函数void AscendSorting(int a[]) ...

    一、解题思路

    1.宏定义数组元素个数为ARRNUM=10
    函数原型声明void AscendSorting(int a[]);
    函数原型声明int Bisearch(int x,int *a[],int left, int right);

    2.设计函数
    2.1设计函数void AscendSorting(int a[])
    2.1.1函数功能
    函数功能为实现对数组进行由小到大排序,排序方法选择效率较高的选择法
    2.1.2 函数内部
    定义变量int i=0,j=0,k=0;
    使用循环的嵌套实现由小到大的排序
    2.1.3 循环内部
    外层循环for(i=0;i<ARRNUM;i++)内对k进行赋值k=i
    内层循环for(j=i+1;j<ARRNUM;j++)内用if语句判断a[j]<a[k]是否成立,成立则k=j
    内层循环结束则用if语句判断k!=i是否成立,成立则令a[i]=a[k]

    2.2设计函数 int Bisearch(int x,int *a[],int left,int right)
    2.2.1函数功能
    如果找到对应数,函数返回值为对应数组下表,否则返回-1
    函数功能为运行折半查找法,在一个有序序列中查找某一特定的数
    2.2.2函数内部
    定义变量mid并初始化为0,int mid=0;
    用while循环实现查找,当查找范围下界小于等于查找范围上界时执行循环,循环判断条件是left<=right
    循环内部
    每一次循环开始时,将mid初始化为查找范围的中位数对应下标,mid=left+(right-left)/2
    用else-if语句判断x与a[mid]大小关系
    如果x==a[mid],则函数返回值为1
    如果x<=a[mid],则令查找范围上界更改为right=mid-1,继续循环
    如果x>=a[mid],则令查找范围下界更改为left=mid+1,继续循环
    如果循环结束,仍为找到用户输入值x,则令函数返回则为-1

    3.主函数内部
    3.1 变量定义
    定义用户输入的数为x、rt,分别初始化为0、-1
    定义数组并初始化a[ARRNUM]={78,99,27,33,54,11,37,28,88,38}
    3.2 数组排序
    调用AscendSorting函数实现数组升序排列
    3.3 用for循环实现有序数组打印输出
    3.4 读入数据
    printf函数提示用户要查找的数,scanf函数读入用户要查找的数x
    3.5 输出查找结果
    将Bisearch函数返回值赋值给rt,rt=Bisearch(x,a,0,sizeof(a)/sizeof(0)-1)
    用else-if语句判断rt==-1 是否成立,成立则输出未找到,否则输出找到

    二、实验代码
    #define ARRNUM 10
    void AscendSorting(int *a)
    {
    int i=0,j=0,k=0,inter=0;
    for(i=0;i<ARRNUM-1;i++)
    {
    k=i;
    for(j=i+1;j<ARRNUM;j++)
    {
    if(a[j]<a[k]) k=j;
    }
    if(i != k)
    {
    inter=a[i];
    a[i]=a[k];
    a[k]=inter;
    }
    }

    #include<stdio.h>
    #include"Bisearch.h"
    int main(void)
    {
    int x=0,rt=0,i=0;
    int Left=0,Right;
    int a[ARRNUM]={78,99,27,33,54,11,37,28,88,38};
    Right=9;
    AscendSorting(a);
    printf(“The array after sorting:\n”);
    for(i=0;i<ARRNUM;i++)
    {
    printf("%d",a[i]);
    printf(" “);
    }
    printf(“Please input the number you want to search within 100:\n”);
    scanf(”%d",&x);
    rt=Bisearch(x,a,Left,Right);
    if(rt==-1)
    {
    printf(“未找到”);
    }
    else
    {
    printf(“找到了%d,在数组第%d个”,x,rt+1);
    }
    return 0;
    }

    展开全文
  • 二分查找算法又叫折半查找算法,算法的效率是很高的,这点毋庸置疑,但其有自己特有的使用范围,仅可以查找有序的数列,对于无序、乱序的数列是不适用的 方法思维: 每次将查找的数列进行折半拆分,也就是一分为二的...

    适用范围:

    二分查找算法又叫折半查找算法,算法的效率是很高的,这点毋庸置疑,但其有自己特有的使用范围,仅可以查找有序的数列,对于无序、乱序的数列是不适用的

    方法思维:

    每次将查找的数列进行折半拆分,也就是一分为二的思想理念,每次匹配一个部分,重复多次,即可查询到相应的数字。

    例如:
    一个[a,b]的闭区间,想查找一个该区间内的值
    将区间一分为2
    第一个为[a , (a+b)/2] 第二个区间为[(a+b)/2,b]
    将需要查找的数分别与这两个区间的最大值和最小值比较
    如果在该区间,则将该区间再次进行拆分,重复多次,直到求解。

    例题:

    编写代码在一个整形有序数组中查找具体的某个数
    要求:找到了就打印数字所在的下标,找不到则输出:找不到。

    #include <stdio.h>
    //二分查找
    /*编写代码在一个整形有序数组中查找具体的某个数
    要求:找到了就打印数字所在的下标,找不到则输出:找不到*/
    int main()
    {
    	//定义这个整型有序数组
    	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13 };
    	//获取数组中元素的个数
    	int num = sizeof(arr) / sizeof(int);
    	int left = 0;
    	int right = num - 1;
    	printf("请输入您要查找的数:");
    	int search;
    	scanf("%d", &search);
    	for (int i = 0; i < num; i++)
    	{
    			int mid = (left + right) / 2;
    
    
    			if (arr[mid] > search)
    			{
    				right = mid + 1;
    
    
    			}
    			else if (arr[mid]<search)
    			{
    				left = mid + 1;
    			}
    			else
    			{
    				printf("找到这个数了,这个数的下标为\"%d\"\n", mid);
    				printf("这个数为\"%d\"\n", arr[mid]);
    				break;
    			}
    	
    		if (left > right)
    		{
    			printf("找不到这数!");
    
    
    		}
    	}
    		
    	return 0;
    }
    
    展开全文
  • 在有序表中利用二分查找算法查找关键字值等于或小于k的结点,m指向正好等于k的结点或l指向关键字正好大于k的结点,然后采用移动插入k结点即可。 本题的难点就是如何利用二分查找算法找到合适的插入位置。 有两...

    题目

    编写一个函数,利用二分查找算法在一个有序表中插入一个关键字k,并保持表的有序性。

    分析

    先在有序表中利用二分查找算法查找关键字值等于或小于k的结点,m指向正好等于k的结点或l指向关键字正好大于k的结点,然后采用移动法插入k结点即可。

    本题的难点就是如何利用二分查找算法找到合适的插入位置。

    有两种情况:第一种是有序表中没有等于关键字k的结点,寻找大于k的结点即可;第二种是有序表中存在等于关键字k的结点,寻找等于k的结点即可。

    图解如下:

    将两种情况用同一部分代码来处理,定义一个标志位变量flag,用来记录是否有等于关键字k的情况,初始为0表示没有等于关键字k的情况,如果有则将flag置为1,然后退出循环,最终根据标志位flag来判断插入位置。

    代码

    核心代码:

    /* 使用二分查找在顺序表中插入元素k */ 
    void insertK(int nums[],int n,int k){
    	int mid;// 记录中间下标 
    	int low=0,high=n-1;
    	int flag=0;// 标志,用来记录是否有等于k的值 
    	int pos;// 定义的变量,为插入的位置 
    	while(low<=high&&flag==0){// 循环当low>high时跳出循环 
    		mid=(low+high)/2;
    		if(nums[mid]==k){
    			flag=1;// 如果发现有关键字等于k,则将标志flag置为1,退出循环然后插入k 
    		}else if(nums[mid]>k){
    			high=mid-1;
    		}else if(nums[mid]<k){
    			low=mid+1;
    		}
    	}
    	/* 确定插入位置 */ 
    	if(flag==1){// 如果flag为1则发现序列中有关键字等于k,则使插入位置等于mid
    		pos=mid; 
    	}else{// 如果flag为0则表示序列中没有与关键字k相等的值,则插入位置为low 
    		pos=low;
    	}
    	/* 插入关键字k */
    	for(int i=n-1;i>=pos;i--){
    		nums[i+1]=nums[i];
    	} 
    	nums[pos]=k;
    }

    完整代码如下:

    #include<stdio.h>
    
    /* 打印数组 */ 
    void printArr(int nums[],int n){
    	printf("\n");
    	for(int i=0;i<n;i++){
    		printf("%d\t",nums[i]);
    	}
    	printf("\n");
    }
    
    /* 使用二分查找在顺序表中插入元素k */ 
    void insertK(int nums[],int n,int k){
    	int mid;// 记录中间下标 
    	int low=0,high=n-1;
    	int flag=0;// 标志,用来记录是否有等于k的值 
    	int pos;// 定义的变量,为插入的位置 
    	while(low<=high&&flag==0){// 循环当low>high时跳出循环 
    		mid=(low+high)/2;
    		if(nums[mid]==k){
    			flag=1;// 如果发现有关键字等于k,则将标志flag置为1,退出循环然后插入k 
    		}else if(nums[mid]>k){
    			high=mid-1;
    		}else if(nums[mid]<k){
    			low=mid+1;
    		}
    	}
    	/* 确定插入位置 */ 
    	if(flag==1){// 如果flag为1则发现序列中有关键字等于k,则使插入位置等于mid
    		pos=mid; 
    	}else{// 如果flag为0则表示序列中没有与关键字k相等的值,则插入位置为low 
    		pos=low;
    	}
    	/* 插入关键字k */
    	for(int i=n-1;i>=pos;i--){
    		nums[i+1]=nums[i];
    	} 
    	nums[pos]=k;
    }
    
    int main(){
    	int nums[]={1,2,3,4,5,6,7};
    	int n=7;
    	int k=5;
    	insertK(nums,n,k);// 插入k
    	printArr(nums,n);// 打印数组 
    	
    	return 0;
    }

    运行结果:

    展开全文
  • 概要引入折半查找基本概念折半查找java代码实现折半查找算法复杂度分析折半查找改进版1:插值查找折半查找改进版2:斐波那契查找总结 引入 顺序查找虽然算法非常简单,对静态查找的记录没有任何要求,但是当查找...
  • 二分查找(binary search)也称为折半查找法,用来查找有序的记录数组的某记录,其基本思想是:将记录按有序化(递增或递减)排列,查找过程如果要找的元素值小于该中点元素,则将待查序列缩小为左半...
  • 有序表的查找——折半查找分析

    千次阅读 2020-06-03 21:31:59
    二分查找要求:线性表是有序表,即表结点按关键字有序,并且要用数组向量作为表的存储结构,不能使用链表,不妨设有序表是递增有序的。 2、二分查找的基本思想 二分查找的基本思想是:(设R[low…high]是当前的...
  • Java有序表查找:折半查找、二分查找、差值查找和斐波那契查找  【尊重原创,转载请注明出处】http://write.blog.csdn.net/postedit?ticket=ST-84189-RPiSkdLK6Dt1Oyqsgvsx-passport.csdn.net  目前查找方法...
  • 查找有序表中的第一个指定元素与最后一个指定元素 Input: 10 5 1 2 3 5 5 5 5 5 6 7 Output: 4 8 指定元素为5时: 第一个指定元素的下标为4 最后一个指定元素的下标为8 话不多说,代码如下(仍然采用折半查找...
  • 折半查找一个有序序列

    千次阅读 2013-08-07 16:19:13
    例如某些电视台的购物广告,让观众猜价格的奖品,可以利用折半查找的思想来进行,第次喊50,主持人会提示高了或者低了,然后有限的机会次数内猜中价格,赢得奖品,现在我们就来看看计算机如何进行折半查找的:
  • 如果大于中间元素,就右子数组中查找,否则中间元素就是要找的元素。 # include&lt;iostream&gt; using namespace std; void init(int a[],int n); void print(int a[],int n); int BinaryRearch...
  • 折半查找算法介绍折半查找(Binary Search)又称为二分查找。它的前提是线性表的记录必须是关键码有序(通常从小到大有序),线性表必须采用顺序存储。从算法名称可以看出算法的思路,先取有序序列中间值与查找值...
  • 有序表——折半查找

    千次阅读 2017-11-12 18:44:25
     在一有序序列,取中间值与给定关键字进行比较,如果给定关键字大于该值关键字,则要查找的关键字位于有序序列的后半部分;若给定小于该值,则要查找的关键字位于有序序列的前半部分。每次将有序序列的长度缩小...
  •  以有序表表示静态查找表时,可用折半查找算法查找指定元素。  折半查找过程是以处于区间中间位置记录的关键字和给定值比较,若相等,则查找成功,若不等,则缩小范围,直至新的区间中间位置记录的关键字等于给定...
  • 查找算法折半查找法

    千次阅读 2020-02-20 17:08:09
    本篇文章将介绍折半查找算法。 文章目录何为折半查找?算法实现递归实现效率分析 何为折半查找? 上篇文章介绍了顺序查找算法,我们知道,虽然顺序查找算法适用性高,但效率太低,那么能不能此基础上继续提高...
  • 有序表折半查找的递归算法

    千次阅读 2017-11-16 20:33:55
    #include #include typedef struct{ int key; }Elemtype; typedef struct{ Elemtype *elem; int length; }Table; int Create(Table &S,int n){ S.elem=(Elemtype *)malloc(n*sizeof(Elemtype));...S.elem){
  • int Recurrence_Search_Bin(SSTable ST,... //用递归方法在有序表ST中二分查找关键字为key的数据元素,若找到则返回该元素的位置,否则返回0 if(floor > roof) return 0; int mid = (floor + roof) / 2; if(k
  • 有序表的查找(折半查找

    千次阅读 2015-12-28 13:09:10
     对有序表可以采用折半查找(binary search),又称二分查找。  设有序数组r记录的关键字值按升序排列为:  r0.key, r1.key, r2.key, …, rm.key, …, rn-1.key  其中,n为记录数。当i时,有ri....
  • C++实现有序表折半查找

    千次阅读 2015-05-12 10:10:26
    折半查找(Binary Search)的查找过程是:先确定等查记录所在范围(区间),然后逐步缩小范围直到找到或找不到该记录为止。 2>算法 3>算法实现 #include using namespace std; #define ARRAY_SIZE 11 /* ...
  • 这是一个有序表查找算法,比如(2,3,4,5,11,22,23,44,55,57,88)这样的有序结构。 折半查找(binary search)的过程:先确定带查记录所在的范围或者区间,然后逐步缩小范围,直到找到或者找不到该记录...
  • 折半查找的基本思想是:在有序表中,取中间记录作为比较对象,若给定值与中间记录的关键字相等,则查找成功;若给定值小于中间记录的关键字,则中间记录的左半区继续查找;若给定值大于中间记录的关键字,则中间...
  • 折半查找法(基于有序数组)

    千次阅读 2018-10-07 18:13:25
    折半查找的方法优点: 比较次数少,查找速度快,平均性能好,要求待查表为有序表 存储结构一定是顺序结构 代码实现: #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; ...
  • //请写出对有序表进行折半查找的非递归算法,并将对应的程序调试运行通过 #include #include #define N 100 typedef int Status; typedef int ElemType;typedef struct {//创建有序表 ElemType *list; int length;...
  • #define _CRT_SECURE_NO_WARNINGS #include<iostream> using namespace std; int main() { int a; int arr[10000]; cin >> a; int i = 0; while (a != 0) { arr[i] = a;...>...
  • 有序表折半查找

    千次阅读 2013-12-26 19:54:17
    折半查找又称二分查找,其基本思想是,顺序存储的有序序列要查找某个关键字,首先用有序序列的中间元素和这关键字作比较,如果小于关键字,则在上半部分查找,如果大于关键字,则在下半部分查找,如果等于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,444
精华内容 6,177
关键字:

利用折半查找算法在一个有序表中