算法之查找算法

1.顺序查找算法
时间复杂度o(n)

//对于无序
int SequenceSearch(vector<int>& src, int target) {
	for (int i = 0; i < src.size(); i++) {
		if (src[i] == target) {
			return i;
		}
	}
	return -1;
}

2.二分查找算法
迭代版本

int DivideSearch(const vector<int>& src, int target) {
	int left = 0;
	int right = src.size() - 1;
	int mid = (right - left) / 2 + left;//防止溢出
	while (left <= right) {
		mid = (right - left) / 2 + left;
		if (src[mid] == target) {
			return mid;
		}
		if (src[mid] < target) {
			left = mid +1;//[mid + 1, right]
		}
		if (src[mid] > target) {
			right = mid - 1;//[left, mid - 1]
		}
	}
	return -1;
}

递归版本

int DivideSearch2(const vector<int>& src, int left, int right, const int target) {

	int mid = left + ((right - left) >> 1);//采用移位 效率比除法高
	if (mid < 0 || mid >= src.size() || right < left)
		return -1;
	if (src[mid] == target)
		return mid;
 	if (src[mid] > target)
		return DivideSearch2(src,  left, mid - 1, target);
	if (src[mid] < target)
		return DivideSearch2(src, mid + 1, right, target);
}

3.插值查找
明显也是需要有序 更改二叉查找的系数1 / 2； 改为int mid = left + (target - src[left]) / (src[right] - src[left]) * (right - left); 原先为int mid = left + (right - left) / 2;改成了靠近目标值的位置查找

int AdaptSeach(const vector<int>& src, int target) {
	int left = 0;
	int right = src.size() - 1;
	int mid = left + (target - src[left]) / (src[right] - src[left]) * (right - left);
	while (left <= right) {
		mid = (left + (target - src[left]) / (src[right] - src[left]) * (right - left));
		if (src[mid] == target) {
			return mid;
		}
		if (src[mid] < target) {
			left = mid + 1;//[mid + 1, right]
		}
		if (src[mid] > target) {
			right = mid - 1;//[left, mid - 1]
		}
	}
	return -1;

}

4.斐波那契查找
有序查找 先构造斐波那契数列再查找
先构造斐波那契数列 然后寻找与容量相近的大于的斐波那契数 使用最后一个元素进行填充 然后查找

摘自百度百科
斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1；开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1)，比较结果也分为三种：
（1）相等，则mid位置的元素即为所求；
（2）>，则low=mid+1，k-=2；
说明：low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))=Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找。
（3））<，则high=mid-1，k-=1。
说明：low=mid+1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归的应用斐波那契查找。
在最坏情况下，斐波那契查找的时间复杂度还是O(log2n)，且其期望复杂度也为O(log2n)，但是与折半查找相比，斐波那契查找的优点是它只涉及加法和减法运算，而不用除法，而除法比加减法要占用更多的时间，因此，斐波那契查找的运行时间理论上比折半查找小，但是还是得视具体情况而定。

/*构造一个斐波那契数组*/
void Fibonacci(vector<int>& F)
{
	F.resize(20);
	F[0] = 0;
	F[1] = 1;
	for (int i = 2; i < max_size; ++i)
		F[i] = F[i - 1] + F[i - 2];
}

int FibSearch(const vector<int>& src, int target) {
	vector<int> F;
	Fibonacci(F);
	int n = src.size();
	int left = 0;
	int right = src.size() - 1;
	int k = 0;
	while (n > F[k] - 1) {
		k++;
	}

	vector<int> temp(src);
	for (int i = n; i < F[k] - 1; ++i)
		temp.push_back(src[n - 1]);

	while (left <= right)
	{
		int mid = left + F[k - 1] - 1;
		if (target < temp[mid])
		{
			right = mid - 1;
			k -= 1;
		}
		else if (target > temp[mid])
		{
			left = mid + 1;
			k -= 2;
		}
		else
		{
			if (mid < n)
				return mid; //若相等则说明mid即为查找到的位置  
			else
				return n - 1; //若mid>=n则说明是扩展的数值,返回n-1  
		}
	}
	return -1;
}

5.树表查找
首先要建立树，再进行查找
之后拓展

6.分块查找
之后拓展

7.哈希查找
以空间换时间
之后拓展