chapter3-排序和查找2

2.基础查找

所谓查找，就是在查找空间中找寻符合要求的解的过程。查找方法有多种，下面简单介绍3种。不同的策略对查找的效率和结果有不同的影响。

2.1 线性查找

从首元素开始，遍历整个序列，直到找到目标元素，则结束算法；或者遍历完序列还没有匹配，则查找失败结束算法。时间复杂度为O(n)。

线性查找

//基础查找-线性查找 2024-02-15
#include <iostream>
#include <cstdio>
 
using namespace std;
 
const int MAXN = 100 + 10;
int arr[MAXN];
 
//线性查找
bool LinearSearch(int n, int target)
{
    for(int i=0; i<n; i++)
    {
        if(target == arr[i])
            return true;
    }
    return false;
}
 
int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%d", &arr[i]);
    }
    int m, target;
    scanf("%d", &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d", &target);
        if(LinearSearch(n, target))
        {
            printf("YES\n");
        }
        else{
            printf("NO\n");
        }
    }
    return 0;
}

2.2 二分查找

二分查找的前提是有序序列。有两种方法，一种是自定义，自己写一个函数用来贴合题面的要求；第二种是内定义，即使用C++内部封装好的函数来实现二分查找。时间复杂度为O(logn)。

2.2.1 自定义

定义两个变量L和R分别指向首元素和序列的尾元素，计算middle，如果middle所指向的元素和要找的目标值target相等，则查找成功，结束算法；否则如果middle所指向的元素比target小，则在右半边继续查找；左半边同理；直至查找到目标值，或者当R<L时算法结束，查找失败。

二分查找_自定义

//基础查找-二分查找-前提序列有序-自定义 2024-02-15
#include <iostream>
#include <cstdio>
#include <algorithm>
 
using namespace std;
 
const int MAXN = 100 + 10;
int arr[MAXN];
 
bool BinarySearch(int n, int target)
{
    int left = 0;
    int right = n-1;
    while(left <= right)
    {
        int middle = left + (right - left)/2;
        if(arr[middle] == target)
        {
            return true;
        }
        else if(arr[middle] < target)//搜索右半部分
        {
            left = middle + 1;
        }
        else{
            right = middle -1;
        }
    }
    return false;
}
 
int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%d", &arr[i]);
    }
    sort(arr, arr+n);//默认compare升序
    int m, target;
    scanf("%d", &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d", &target);
        if(BinarySearch(n, target))
        {
            printf("YES\n");
        }
        else{
            printf("NO\n");
        }
    }
    return 0;
}

2.2.2 内定义

C++内部封装了两个用于实现二分查找的函数，即lower_bound和upper_bound。需要引用头文件#include <algorithm>

1、lower_bound：返回大于或等于目标值的第一个位置。
2、upper_bound：返回大于目标值的第一个位置。

lower_bound(first, last, target)有三个参数，分别是有序序列的起始地址、结束地址和目标值，target可为任意数据类型。
注意考虑lower_bound在查找目标值时的3种情况。其一如上图所示；其二是有序序列中没有目标值，lower_bound会返回最靠近目标值而大于目标值的元素的下标；其三，要查找的target值大于有序序列的最大值，此时lower_bound会移出序列，指向下标n，即越界访问。
注意：lower_bound函数返回的不是数组元素的下标，而是元素所在的地址，减去数组起始地址，即可得到数组下标。int position = lower_bound(arr, arr+n, target) - arr;

二分查找_内定义

//基础查找-二分查找-前提序列有序-内定义 2024-02-15
#include <iostream>
#include <cstdio>
#include <algorithm>
 
using namespace std;
 
const int MAXN = 100 + 10;
int arr[MAXN];
 
int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%d", &arr[i]);
    }
    sort(arr, arr+n);//默认compare升序
    int m, target;
    scanf("%d", &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d", &target);
        int position = lower_bound(arr, arr + n, target) - arr ;
        if(position != n && arr[position] == target)
        {
            printf("YES\n");
        }
        else{
            printf("NO\n");
        }
    }
    return 0;
}

2.3 散列查找

线性查找和二分查找都是以数组下标为索引，去遍历查找target值，而散列查找使用散列函数，使得元素值经过常数时间的Hash函数计算后，直接得到其下标索引。时间复杂度为O(1)。
散列查找也有两种方法，一种是自定义，一种是内定义。

2.3.1 自定义

这里散列函数搞一个最简单的线性映射，即开一个和数据范围一样大的bool型辅助数组，在输入元素时，给对应的辅助数组赋值为true。未得到赋值的默认为false。

散列查找_自定义

//基础查找-散列查找 2024-02-15
#include <iostream>
#include <cstdio>
#include <algorithm>
 
using namespace std;
 
const int MAXN = 100 + 10;
const int RANGE = 1e6;
int arr[MAXN];
bool hashTable[RANGE];
 
int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%d", &arr[i]);
        hashTable[arr[i]] = true;
    }
    sort(arr, arr+n);//默认compare升序
    int m, target;
    scanf("%d", &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d", &target);
        if(hashTable[target])
        {
            printf("YES\n");
        }
        else{
            printf("NO\n");
        }
    }
    return 0;
}

2.3.2 内定义

C++内部封装了散列函数unordered_map，需要引用头文件#include <unordered_map>。

散列查找_内定义

//基础查找-散列查找-内定义 2024-02-15
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <unordered_map>
 
using namespace std;
 
const int MAXN = 100 + 10;
 
int arr[MAXN];
unordered_map<int, bool> hashTable;//1：元素的类型；2：是否出现过用bool表示
//相当于定义了一个辅助数组用于线性映射，就是散列函数
int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
    {
        scanf("%d", &arr[i]);
        hashTable[arr[i]] = true;
    }
    sort(arr, arr+n);//默认compare升序
    int m, target;
    scanf("%d", &m);
    for(int i=0; i<m; i++)
    {
        scanf("%d", &target);
        if(hashTable[target])
        {
            printf("YES\n");
        }
        else{
            printf("NO\n");
        }
    }
    return 0;
}

3.参考资料

1.C++ upper_bound()函数
2.rgb颜色对照表