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.哈希查找
以空间换时间
之后拓展