C++秋招必知必会（常用搜索算法）

参考引用

• Hello 算法

常用搜索算法

1. 绪论

• 搜索算法用于在数据结构（数组、链表、树或图）中搜索一个或一组满足特定条件的元素，分为以下两类
  • 1. 暴力搜索：通过遍历数据结构来定位目标元素，例如数组、链表、树和图的遍历等
    • 1.1 线性搜索：适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止
    • 1.2 广度优先搜索 和 1.3 深度优先搜索：是图和树的两种遍历策略，广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点；深度优先搜索从初始节点开始，沿着一条路径走到头，再回溯并尝试其他路径，直到遍历完整个数据结构

    暴力搜索的优点是简单且通用性好，无须对数据做预处理和借助额外的数据结构，但在数据量较大的情况下性能较差

  • 2. 自适应搜索：利用数据组织结构或数据包含的先验信息实现高效元素查找，例如二分查找、哈希查找和二叉搜索树查找等
    • 2.1 二分查找：利用数据的有序性实现高效查找，仅适用于数组
    • 2.2 哈希查找：利用哈希表将搜索数据和目标数据建立为键值对映射，从而实现查询操作
    • 2.3 树查找：在特定的树结构（例如二叉搜索树）中，基于比较节点值来快速排除节点，从而定位目标元素

    自适应搜索效率高，但往往需要对数据进行预处理：例如，二分查找需要预先对数组进行排序，哈希查找和树查找都需要借助额外的数据结构，维护这些数据结构也需要额外的时间和空间开销

• 搜索算法选取原则
  • 线性搜索
    • 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
    • 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护
  • 二分查找
    • 适用于大数据量的情况，效率表现稳定（数据量不能过大，因为存储数组需要连续的内存空间）
    • 不适用于高频增删数据的场景，因为维护有序数组的开销较大
  • 哈希查找
    • 适合对查询性能要求很高的场景
    • 不适合需要有序数据或范围查找的场景，因为哈希表无法维护数据的有序性
    • 不适合数据量过大的情况，因为哈希表需要额外空间来最大程度地减少冲突
    • 对哈希函数和哈希冲突处理策略的依赖性较高，具有较大的性能劣化风险
  • 树查找
    • 适用于海量数据，因为树节点在内存中是分散存储的
    • 适合需要维护有序数据或范围查找的场景

2. 二分查找

2.1 算法原理与流程

• 二分查找是一种基于分治策略的高效搜索算法，它利用数据的有序性，每轮缩小一半搜索范围，直至找到目标元素或搜索区间为空为止
• 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1
• 使用二分法的前提条件
  • 数组为有序数组
  • 数组中无重复元素
• 二分法核心思想
  • 在二分查找的过程中，保持不变量，即：在 while 寻找每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
  • 区间的定义一般为两种，左闭右闭即 [left, right]，或者左闭右开即 [left, right)
    

2.2 算法实现

• 时间复杂度 $O(logn)$：在二分循环中，区间每轮缩小一半，因此循环次数为 ${\log }_{2}n$
• 空间复杂度 $O(1)$：指针 $i$ 和 $j$ 使用常数大小空间

#include <iostream>
#include <vector>

int binarySearch(std::vector<int> &nums, int target) {
    int left = 0;
    int right = nums.size() - 1; // 定义t arget 在左闭右闭的区间里，[left, right]
    while (left <= right) { // 当 left==right，区间 [left, right] 依然有效，所以用 <=
        int middle = left + ((right - left) / 2); // 防止溢出 等同于 (left + right)/2
        if (nums[middle] > target) {
            right = middle - 1; // target 在左区间，所以 [left, middle - 1]
        } else if (nums[middle] < target) {
            left = middle + 1; // target 在右区间，所以[middle + 1, right]
        } else { // nums[middle] == target
            return middle; // 数组中找到目标值，直接返回下标
        }
    }
    // 未找到目标值
    return -1;
}

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 1, 2, 3, 4, 7, 9, 10 };
    int target = 2;

    int result = binarySearch(nums, target);
    std::cout << result << std::endl;

    return 0;
}

二分查找的优缺点

• 优点：（1）时间效率高，当数据大小 $n=2^{20}$ 时，线性查找需要 $2^{20}=1048576$ 轮循环，而二分查找仅需 ${\log }_2{2}^{20}=20$ 轮循环；（2）相较于需要借助额外空间的搜索算法（例如哈希查找）更节省空间
• 缺点：（1）二分查找仅适用于有序数据，若输入数据无序，为使用二分查找而专门进行排序，得不偿失；（2）仅适用于数组，二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低；（3）小数据量下，线性查找性能更佳

3. 线性搜索与哈希查找

• 给定一个整数数组 nums 和一个目标元素 target ，请在数组中搜索 “和” 为 target 的两个元素，并返回它们的数组索引，返回任意一个解即可

3.1 线性搜索：以时间换空间

• 考虑直接遍历所有可能的组合，开启一个两层循环，在每轮中判断两个整数的和是否为 target，若是，则返回它们的索引
  

// 时间复杂度为 O(n^2)
// 空间复杂度为 O(1)
#include <iostream>
#include <vector>

std::vector<int> twoSumBruteForce(std::vector<int> &nums, int target) {
    int size = nums.size();
    // 两层循环，时间复杂度为 O(n^2)
    for (int i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
            if (nums[i] + nums[j] == target)
                return {i, j};
        }
    }
    return {};
}

int main() {
    std::vector<int> nums = {2, 7, 11, 15};
    int target = 9;
    
    std::vector<int> result = twoSumBruteForce(nums, target);
    
    if (result.size() == 2) {
        std::cout << "Indices: " << result[0] << ", " << result[1] << std::endl;
    } else {
        std::cout << "No two elements in the vector sum up to the target." << std::endl;
    }
    
    return 0;
}

3.2 哈希查找：以空间换时间

• 考虑借助一个哈希表，键值对分别为数组元素和元素索引，循环遍历数组，每轮执行下图所示的步骤
  • 判断数字 target - nums[i] 是否在哈希表中，若是，则直接返回这两个元素的索引
  • 将键值对 nums[i] 和索引 i 添加进哈希表
    

// 时间复杂度由 O(n^2) 降为 O(n)，大幅提升运行效率
// 空间复杂度由 O(1) 升为 O(n)，因为需要维护一个额外的哈希表
#include <iostream>
#include <vector>
#include <unordered_map>

std::vector<int> twoSumHashTable(std::vector<int> &nums, int target) {
    int size = nums.size();
    // 辅助哈希表，空间复杂度为 O(n)
    std::unordered_map<int, int> dic;
    // 单层循环，时间复杂度为 O(n)
    for (int i = 0; i < size; i++) {
        if (dic.find(target - nums[i]) != dic.end()) {
            return {dic[target - nums[i]], i};
        }
        dic.emplace(nums[i], i);
    }
    return {};
}

int main() {
    std::vector<int> nums = {2, 7, 11, 15};
    int target = 9;
    
    std::vector<int> result = twoSumHashTable(nums, target);
    
    if (result.size() == 2) {
        std::cout << "Indices: " << result[0] << ", " << result[1] << std::endl;
    } else {
        std::cout << "No two elements in the vector sum up to the target." << std::endl;
    }
    
    return 0;
}