二分检索

二分检索

二分检索(Binary Search)也叫二分查找,是应用于有序表上的一种检索方法。二分检索的思想是:由于序列已经有序,故不需要顺序遍历,每次只需和序列中间位置的元素进行比较即可,以此确定下次查找的位置。显然每次都可以排除一半的元素,很高效。

二分检索伪代码

BinarySearch(Array, key)

1.low=0,high-n-1;

2.while(low<=high)

3.    mid=(low+high)/2;

4.    if(key<array[mid])

5.        high=mid-1;

6.    else if(key>array[mid])

7.        low=mid+1;

8.    else

9.        printf("查找成功!");

10. printf("查找失败!");

一个二分检索的例子

有序序列  2  5  7  9  12  15

下标      0  1  2  3  4   5

(i)查找 7

初始范围 low=0; high=5

第一次比较 范围[0,5]

mid=(low+high)/2=2;

array[2]=7

5<7,故 high=mid-1;

第二次比较 范围[0,1]

mid=(low+high)/2=0;

array[0]=2

5>2,故 low=mid+1;

第三次比较 范围[1,1]

mid=(low+high)/2=1;

array[1]=7

查找成功!

(ii)查找 6

初始范围 low=0; high=5

第一次比较 范围[0,5]

mid=(low+high)/2=2;

array[2]=7

6<7,故 high=mid-1;

第二次比较 范围[0,1]

mid=(low+high)/2=0;

array[0]=2

6>2,故 low=mid+1;

第三次比较 范围[1,1]

mid=(low+high)/2=1;

array[1]=7

6<7,故 high=mid-1;

此时 low=1, high=0; 不符合继续查询的条件,查找失败!

下面直接用完整的实例给出二分检索在两种查询区间下的代码:

代码

#include<stdio.h>
#include<stdlib.h>
bool BinarySearch1(int array[], int n, int key)
{
	if (array && n > 0)
	{
		int low, high, mid;
		low = 0, high = n - 1;
		//查找区间[low,high],区间不同,high的变化也不同
		while (low <= high)
		{
			/*
			这种写法既高效,又可有效的避免溢出问题
			注意:右移运算符的优先级小于加法运算,所以需加括号
			*/
			mid = low + ((high - low) >> 2);
			if (key < array[mid])
				high = mid - 1;
			else if (key > array[mid])
				low = mid + 1;
			else//相等,则查找成功
				return true;
		}
	}
	//序列不存在或查找失败
	return false;
}
bool BinarySearch2(int array[], int n, int key)
{
	if (array && n > 0)
	{
		int low, high, mid;
		//查找区间[low,high)
		low = 0, high = n;
		while (low < high)
		{
			mid = low + ((high - low) >> 2);
			if (key < array[mid])
				high = mid;
			else if (key > array[mid])
				low = mid + 1;
			else
				return true;
		}
	}
	return false;
}
//打印
void print(int array[], int n)
{
	if(array && n>0)
	{
		int i;
		for (i = 0; i < n; i++)
			printf("%4d",array[i]);
		printf("\n");
	}
}
int main()
{
	printf("***二分检索***by David***\n");
	int array[] = {2,5,7,9,12,15};
	int n = sizeof(array) / sizeof(array[0]);
	printf("原序列\n");
	print(array, n);
	int key;
	key = 7;
	printf("查找 %d\n",key);
	BinarySearch1(array, n, key) ? printf("查找成功!\n") : printf("查找失败!\n");
	BinarySearch2(array, n, key) ? printf("查找成功!\n") : printf("查找失败!\n");
	key = 6;
	printf("查找 %d\n", key);
	BinarySearch1(array, n, key) ? printf("查找成功!\n") : printf("查找失败!\n");
	BinarySearch2(array, n, key) ? printf("查找成功!\n") : printf("查找失败!\n");
	system("pause");
	return 0;
}

运行

可以在while循环中插入一些代码打印low和high,观察low和high的变化,以加深对循环条件的认识。

转载请注明出处,本文地址;http://blog.csdn.net/zhangxiangdavaid/article/details/37738423

若有所帮助,顶一个哦!

专栏目录:数据结构与算法目录

二分检索,布布扣,bubuko.com

时间: 2024-10-09 23:35:46

二分检索的相关文章

二分检索的多种应用

其实,二分法真的不那么简单,尤其是二分法的各个变种. 最最简单的二分法,就是从一个排好序的数组之查找一个key值. 如下面的程序: int search(int *arr, int n, int key) { int left = 0, right = n-1; while(left<=right) { int mid = left + ((right - left) << 1); if (arr[mid] == key) return mid; else if(arr[mid] >

C++实现二分检索算法

C++实现二分检索算法#include <iostream>#include <iomanip>#include<stdlib.h>using namespace std;void enter(int arrayin[], int n); //输入函数void asort(int arrayin[], int n); //排序函数int Search(int number,int arraylength,int array[]); //查找函数const int N=1

二分检索函数lower_bound()和upper_bound()

二分检索函数lower_bound()和upper_bound() 一.说明 头文件:<algorithm> 二分检索函数lower_bound()和upper_bound() lower_bound():找到大于等于某值的第一次出现upper_bound():找到大于某值的第一次出现必须从小到大排序后才能用 内部查找方式为二分查找,二分查找必定需要排序 返回值为地址 二.代码及结果 1 /* 2 二分检索函数lower_bound()和upper_bound() 3 lower_bound(

(每日算法)LeetCode --- Search in Rotated Sorted Array(旋转数组的二分检索)

Search in Rotated Sorted Array I && II Leetcode 对有序数组进行二分查找(下面仅以非递减数组为例): int binarySort(int A[], int lo, int hi, int target) { while(lo <= hi) { int mid = lo + (hi - lo)/2; if(A[mid] == target) return mid; if(A[mid] < target) lo = mid + 1;

二分检索,顺序检索模板

#include <stdlib.h> #include <iostream> using namespace std; int cmp(const void *a, const void *b) { return ( *(int *)a - *(int *)b ); } int binary_search( int *a, int n, int key ) //二份检索 { qsort(a, n, sizeof(a[0]), cmp); int mid, front=0, bac

查找算法总结(二分查找/二叉查找树/红黑树/散列表)

1.二分查找 二分查找时,先将被查找的键和子数组的中间键比较.如果被查找的键小于中间键,就在左子数组继续查找,如果大于中间键,就在右子数组中查找,否则中间键就是要找的元素. /** * 二分查找 */ public class BinarySearch { public static int find(int[] array, int key) { int left = 0; int right = array.length - 1; // while (left <= right)不能改为<

算法实现回顾1——二分查找

前话: 为什么写这个系列?算法的精髓除了在于算法的一个设计,更在于算法的一个好的设计.前者可能需求一个好的算法工程师,而后者则需求一个优秀的程序员.很多时候我们往往只希望去了解一种设计思路,但是对于程序员,一种优良的实现是非常重要的.实现的细节才决定成败.毕竟程序员面对和输出的都是程序,而不是思路. 引用: 你真的会二分查找吗?http://blog.csdn.net/int64ago/article/details/7425727二分查找,你真的会吗?http://www.ahathinkin

如何计算时间复杂度

本文是转载的,原作者不详. 一.概念 时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数) 比如:一般总运算次数表达式类似于这样: a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f a ! =0时,时间复杂度就是O(2^n); a=0,b<>0 =>O(n^3); a,b=0,c<>0 =>O(n^2)依此类推 eg: (1) for(i=1;i<=n;i++) //循环了n*n次,当然是O(n^2) for(j=1;j<=

时间复杂度

一概念 时间复杂度是总运算次数表达式中受n的变化影响最大的那一项(不含系数) 比如:一般总运算次数表达式类似于这样: a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f a ! =0时,时间复杂度就是O(2^n); a=0,b<>0 =>O(n^3); a,b=0,c<>0 =>O(n^2)依此类推 二.计算方法 1.一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才能知道.但我们不可能也没有必要对每个算法都上机测试,只需知道哪个算法花