算法---分治策略（二分查找）

一、二分查找

二分查找也成为二分折半查找，在有序的数组中（数据量较大）查找一个数据速度是很快的，类似于二分查找的思想在生活中也是处处可见的。

就比如说猜数字游戏：
在1-100之间猜到对方想到的数字
首先说56，对方说小了，那么接下来你说出数字的范围肯定就在57-100之间
再一次78，对方说大了，那么接下来就要在57-77之间
…

次数	范围	说出的数据	实际数字
第一次	0-100	56	60
第二次	57-100	78	60
第三次	57-77	65	60
…	…	…	…

---

而二分查找的思想就是每一次说出的都是范围中间的数字

二、代码展示

#include<stdio.h>
#include<assert.h>

//非递归二分查询
int BinaryFindValue(const int* ar, int n, int val)
{
	assert(ar != NULL);
	int pos = -1;
	int left = 0,right = n - 1;
	while(left < right)
	{ //while判断条件不能有等于，当left == right的时候，left 与right表示的范围中还有一个数据，不能结束
		//int mid = (right + left) / 2;
		int mid = (right - left) / 2 + left;//防止数组过长，超过int可容纳范围
		if(val < ar[mid])
		{
			right = mid - 1;
		}
		else if(val > ar[mid])
		{
			left = mid + 1;
		}
		else
		{
			pos = mid;
			break;
		}
	}
	return pos;
}


int FindValue(const int* ar, int left, int right, int val)
{
	int pos = -1;
	if(left <= right)
	{
		int mid = (right - right) / 2 + left;
		if(val < ar[mid])
		{
			pos = FindValue(ar, left, mid - 1, val);
		}
		else if(val > ar[mid])
		{
			pos = FindValue(ar, mid + 1, right, val);
		}
		else 
		{
			pos = mid;
		}
	}
	return pos;
}
//递归二分查询
int BinFindValue(const int* ar, int n, int val)
{
	assert(ar != NULL);
	return Findvalue(ar, 0, n - 1, val)
}


int main()
{
	int ar[] = { 12,23,34,45,56,67,78,89,90,100 };
	int n = sizeof(ar) / sizeof(ar[0]);
	int val;
	cin>>val;
	int pos = BinaryFindValue(ar, n, val);
	cout << pos << endl;
	
	return 0;
	
}

以上的二分查找虽然说可以找到想要的数据，但是如果想要查找的数据是有重复的{12，12，12，23，23，23，23，23，23，23，34，56，67，78，89}，那么上面的算法就要改进一下。

就拿非递归的来说：

//非递归二分查询（有重复值，要求找到最左边）
int BinaryFindValue(const int* ar, int n, int val)
{
	assert(ar != NULL);
	int pos = -1;
	int left = 0,right = n - 1;
	while(left < right)
	{ //while判断条件不能有等于，当left == right的时候，left 与right表示的范围中还有一个数据，不能结束
		//int mid = (right + left) / 2;
		int mid = (right - left) / 2 + left;//防止数组过长，超过int可容纳范围
		if(val < ar[mid])
		{
			right = mid - 1;
		}
		else if(val > ar[mid])
		{
			left = mid + 1;
		}
		else
		{
			/*
			while(mid > left && ar[mid - 1] == val)//如果想要查找的数据重复过多，此方式时间复杂度过高
			{
				mid = mid - 1;
			}
			pos = mid;
			break;
			*/
			if(ar[mid - 1] != val)
			{
				pos =  mid;
				break;
			}
			right = mid - 1;
		}
	}
	return pos;
}

三、总结

二分查找的每一次子查找都会使范围折半，所以说查找速度还是十分惊人的，其时间复杂度为O(logN)，

**二分查找前提是数组，链表不行
**二分查找在有序的数组中经常被用到
**如果数组中的数据量过小，二分查找不一定就是最佳选择