顺序查找 二分查找 插值查找

顺序查找：

顺序查找的原理很简单，就是遍历整个列表，逐个进行记录的关键字与给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录。如果直到最后一个记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找失败。

#include<iostream>
using namespace std;
int Sequential_search(int a[], int key, int len)
{
	int not_find = -1;
	for (int i = 0; i < len; i++)
	{
		if (a[i] == key)
			return a[i];
	}
	return not_find;
}

int main()
{
	int a[13] = { 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
	int len = sizeof(a) / (sizeof(a[0]));
	cout << Sequential_search(a, 321, len) << endl;
	return 0;
}

顺序查找设置哨兵

#include<iostream>
using namespace std;
#define not_find -1
int Sequential_search(int a[], int key, int len)
{
	a[0] = key;		//a[0]位置放置哨兵
	int i = len;
	while (a[i]!=key)
	{
		i--;
	}
	if (i != 0)
		return a[i];
	else			//下标为0表示没找到
		return not_find;
}
int main()
{
	//数据的0号位置不放元素，留给哨兵使用
	int a[] = { 0, 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
	int len = sizeof(a) / (sizeof(a[0]));
	cout << Sequential_search(a, 321, len-1) << endl;
	return 0;
}

设置哨兵比没有哨兵性能提升了30%~40%

循环中，没有哨兵的程序有3条指令而设置哨兵的程序有两条指令，少了i<n这个比较操作，所以方案2性能得到了提升，这也是哨兵元素的妙用。

二分查找：

基本思路：

首先将给定的关键字key与表array的中间位置的元素进行比较。如果相等，则查找成功，如果不相等，则查找的元素一定在表的前半部分或者后半部分。继续缩小范围到前半部分或者后半部分再进行同样的查找，直到找到为止，或者查完之后仍然没有找到元素。

情况一：表array为容器

#include<iostream>
#include<vector>
using namespace std;
int Binary_search(vector<int> vec,int key)
{
	int not_find = -1;
	int left = 0, right = vec.size()-1;
	int mid;
	while (left<=right)							//相等时继续查找
	{
		mid = (left + right) / 2;				//mid也参与循环，每次再left与right之间
		if (vec[mid]>key)
			right = mid - 1;
		else if (vec[mid] < key)
			left = mid + 1;
		else return mid;
	}
	return not_find;
}

int main()
{
	int a[13] = {5,16,39,45,51,98,100,202,226,321,368,444,501};
	int len = sizeof(a) / (sizeof(a[0]));
	vector<int>vec;
	for (int i = 0; i < len; i++)
		vec.push_back(a[i]);
	cout << Binary_search(vec, 39)<<endl;
	return 0;
}

情况二：表array为数组

数组的两个特殊性质对我们定义和使用作用在数组上的函数有影响，这两个性质分别是：
不允许拷贝数组以及使用数组时通常会将其转换成指针。因为不能拷贝数组，所以我们无法以值传递的方式使用数组参数。因为数组会被转换成指针，所以当我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。

主函数传递给其他函数的数组是一个数组首地址的指针，并不知道数组长度，所以将数组长度也作为形参之一，一并传入

#include<iostream>
#include<vector>
using namespace std;
int Binary_search(int a[], int key,int len)	//数组作为函数形参，由于实参自动地转换成指向首元素的指针,所以需要传递数组长度
{
	int not_find = -1;
	int left = 0, right = len - 1;
	int mid;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (a[mid] == key)
			return mid;
		else if (a[mid] > key)
			right = mid - 1;
		else
			left = mid + 1;
	}
	return not_find;
}

int main()
{
	int a[13] = { 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
	int len = sizeof(a) / (sizeof(a[0]));
	cout << Binary_search(a, 321,len) << endl;
	return 0;
}

插值查找：

首先考虑一个新问题，为什么一定要是折半，而不是折四分之一或者折更多呢？
打个比方，在英文字典里面查“apple”，你下意识翻开字典是翻前面的书页还是后面的书页呢？如果再让你查“zoo”，很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。
同样的，比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5， 我们自然会考虑从数组下标较小的开始查找。
经过以上分析，折半查找这种查找方式，还是有改进空间的，并不一定是折半的！

mid = （left+right）/ 2, 即 mid = left + 1/2 * (right - left);
改进为：
mid = left + (right - left)*(key - a[left]) / (a[right] - a[left]);

也就是将上述的比例参数1/2改进了，根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

分析：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么差值查找未必是很合适的选择。

代码如下

#include<iostream>
using namespace std;
int insert_search(int a[], int key,int n)
{
	int not_found = -1;
	int left = 0, right = n - 1;
	int mid;
	while (left <= right)
	{
		mid = left + (right - left)*(key - a[left]) / (a[right] - a[left]);
		if (a[mid] > key)
			right = mid - 1;
		else if (a[mid] < key)
			left = mid + 1;
		else
			return mid;
	}
	return not_found;
}

int main()
{
	int a[13] = { 5, 16, 39, 45, 51, 98, 100, 202, 226, 321, 368, 444, 501 };
	int len = sizeof(a) / (sizeof(a[0]));
	cout << insert_search(a, 226,len) << endl;
	return 0;
}