数据结构与算法(七):搜索算法

参考引用

  • Hello 算法
  • Github:hello-algo

1. 二分查找

  • 二分查找(binary search)是一种基于分治策略的高效搜索算法。它利用数据的有序性,每轮减少一半搜索范围,直至找到目标元素或搜索区间为空为止

给定一个长度为 n 的数组 nums ,元素按从小到大的顺序排列,数组不包含重复元素。请查找并返回元素 target 在该数组中的索引。若数组不包含该元素,则返回 -1

  • 先初始化指针 i = 0 和 j = n - 1,分别指向数组首元素和尾元素,代表搜索区间 [0, n-1]。请注意,中括号表示闭区间,其包含边界值本身。接下来,循环执行以下两步
    • 计算中点索引 m = (i + j) / 2
    • 判断 nums[m] 和 target 的大小关系,分为以下三种情况
      • 当 nums[m] < target 时,说明 target 在区间 [m+1, j] 中,因此执行 i = m + 1
      • 当 nums[m] > target 时,说明 target 在区间 [i, m-1] 中,因此执行 j = m - 1
      • 当 nums[m] = target 时,说明找到 target ,因此返回索引 m

    若数组不包含目标元素,搜索区间最终会缩小为空。此时返回 -1

/* 二分查找(左闭右闭) */
// 时间复杂度:O(log n)
// 空间复杂度:O(1)
int binarySearch(vector<int> &nums, int target) {
    // 初始化双闭区间 [0, n-1] ,即 i, j 分别指向数组首元素、尾元素
    int i = 0, j = nums.size() - 1;
    // 循环,当搜索区间为空时跳出(当 i > j 时为空)
    while (i <= j) {
        int m = i + (j - i) / 2; // 计算中点索引 m(避免大数越界)
        if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j] 中
            i = m + 1;
        else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
            j = m - 1;
        else // 找到目标元素,返回其索引
            return m;
    }
    // 未找到目标元素,返回 -1
    return -1;
}

1.1 区间表示方法

  • 除了上述的左闭右闭区间外,常见的区间表示还有左闭右开区间,定义为 [0, n),即左边界包含自身,右边界不包含自身。在该表示下,区间 [i, j] 在 i = j 时为空
    /* 二分查找(左闭右开) */
    int binarySearchLCRO(vector<int> &nums, int target) {
        // 初始化左闭右开 [0, n) ,即 i, j 分别指向数组首元素、尾元素+1
        int i = 0, j = nums.size();
        // 循环,当搜索区间为空时跳出(当 i = j 时为空)
        while (i < j) {
            int m = i + (j - i) / 2; // 计算中点索引 m
            if (nums[m] < target)    // 此情况说明 target 在区间 [m+1, j) 中
                i = m + 1;
            else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
                j = m;
            else // 找到目标元素,返回其索引
                return m;
        }
        // 未找到目标元素,返回 -1
        return -1;
    }
    

1.2 优点与局限性

  • 二分查找在时间和空间方面都有较好的性能

    • 二分查找的时间效率高。在大数据量下,对数阶的时间复杂度具有显著优势
    • 二分查找无须额外空间。相较于需要借助额外空间的搜索算法(例如哈希查找),二分查找更节省空间
  • 二分查找并非适用于所有情况

    • 二分查找仅适用于有序数据。若输入数据无序,为了使用二分查找而专门进行排序,得不偿失。因为排序算法的时间复杂度通常为 O(nlog n),比线性查找和二分查找都更高
    • 二分查找仅适用于数组。二分查找需要跳跃式(非连续地)访问元素,而在链表中执行跳跃式访问的效率较低,因此不适合应用在链表或基于链表实现的数据结构
    • 小数据量下,线性查找性能更佳

2. 二分查找插入点

  • 二分查找不仅可用于搜索目标元素,还可搜索目标元素的插入位置

2.1 无重复元素的情况

给定一个长度为 n 的有序数组 nums 和一个元素 target ,数组不存在重复元素。现将 target 插入到数组 nums 中,并保持其有序性。若数组中已存在元素 target ,则插入到其左方。请返回插入后 target 在数组中的索引

数据结构与算法(七):搜索算法_第1张图片

  • 当数组中包含 target 时,插入点的索引是否是该元素的索引?

    • 题目要求将 target 插入到相等元素的左边,这意味着新插入的 target 替换了原来 target 的位置。也就是说,当数组包含 target 时,插入点的索引就是该 target 的索引
  • 当数组中不存在 target 时,插入点是哪个元素的索引?

    • 当 nums[m] < target 时 i 移动,这意味着指针 i 在向大于等于 target 的元素靠近。同理,指针 j 始终在向小于等于 target 的元素靠近
    • 因此二分结束时一定有:i 指向首个大于 target 的元素,j 指向首个小于 target 的元素
    • 综上所述,当数组不包含 target 时,插入索引为 i
    /* 二分查找插入点(无重复元素) */
    int binarySearchInsertionSimple(vector<int> &nums, int target) {
        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
        while (i <= j) {
            int m = i + (j - i) / 2; // 计算中点索引 m
            if (nums[m] < target) {
                i = m + 1; // target 在区间 [m+1, j] 中
            } else if (nums[m] > target) {
                j = m - 1; // target 在区间 [i, m-1] 中
            } else {
                return m; // 找到 target ,返回插入点 m
            }
        }
        // 未找到 target ,返回插入点 i
        return i;
    }
    

2.2 存在重复元素的情况

  • 假设数组中存在多个 target,则普通二分查找只能返回其中一个 target 的索引,而无法确定该元素的左边和右边还有多少 target。题目要求将目标元素插入到最左边,所以需要查找数组中最左一个 target 的索引
  • 每轮先计算中点索引 m,再判断 target 和 nums[m] 大小关系,分为以下几种情况
    • 当 nums[m] < target 或 nums[m] > target 时,说明还没有找到 target,因此采用普通二分查找的缩小区间操作,从而使指针 i 和 j 向 target 靠近
    • 当 nums[m] == target 时,说明小于 target 的元素在区间 [i, m-1] 中,因此采用 j = m-1 来缩小区间,从而使指针 j 向小于 target 的元素靠近(对应寻找最左一个 target 的索引)
  • 循环完成后,i 指向最左边的 target,j 指向首个小于 target 的元素,因此索引 i 就是插入点
    /* 二分查找插入点(存在重复元素) */
    int binarySearchInsertion(vector<int> &nums, int target) {
        int i = 0, j = nums.size() - 1; // 初始化双闭区间 [0, n-1]
        while (i <= j) {
            int m = i + (j - i) / 2; // 计算中点索引 m
            if (nums[m] < target) {
                i = m + 1; // target 在区间 [m+1, j] 中
            } else if (nums[m] > target) {
                j = m - 1; // target 在区间 [i, m-1] 中
            } else {
                j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
            }
        }
        // 返回插入点 i
        return i;
    }
    

3. 二分查找边界

给定一个长度为 n 的有序数组 nums,数组可能包含重复元素。请返回数组中最左一个元素 target 的索引。若数组中不包含该元素,则返回 -1

3.1 查找左边界

  • 二分查找插入点的方法,搜索完成后 i 指向最左一个 target,因此查找插入点本质上是在查找最左一个 target 的索引。因此考虑通过查找插入点的函数实现查找左边界
    • 请注意,数组中可能不包含 target,这种情况可能导致以下两种结果
      • 插入点的索引 i 越界
      • 元素 nums[i] 与 target 不相等

    当遇到以上两种情况时,直接返回 -1 即可

    /* 二分查找最左一个 target */
    int binarySearchLeftEdge(vector<int> &nums, int target) {
        // 等价于查找 target 的插入点
        int i = binarySearchInsertion(nums, target);
        // 未找到 target ,返回 -1
        if (i == nums.size() || nums[i] != target) {
            return -1;
        }
        // 找到 target ,返回索引 i
        return i;
    }
    

3.2 查找右边界

  • 可以利用查找最左元素的函数来查找最右元素,具体方法为

    • 将查找最右一个 target 转化为查找最左一个 target + 1
  • 如下图示,查找完成后,指针 i 指向最左一个 target + 1(如果存在),而 j 指向最右一个 target,因此返回 j 即可

数据结构与算法(七):搜索算法_第2张图片

返回的插入点是 i,因此需要将其减 1,从而获得 j

/* 二分查找最右一个 target */
int binarySearchRightEdge(vector<int> &nums, int target) {
    // 转化为查找最左一个 target + 1
    int i = binarySearchInsertion(nums, target + 1);
    // j 指向最右一个 target ,i 指向首个大于 target 的元素
    int j = i - 1;
    // 未找到 target ,返回 -1
    if (j == -1 || nums[j] != target) {
        return -1;
    }
    // 找到 target ,返回索引 j
    return j;
}

4. 哈希优化策略

  • 通过将线性查找替换为哈希查找来降低算法的时间复杂度

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

4.1 线性查找:以时间换空间

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

数据结构与算法(七):搜索算法_第3张图片

/* 方法一:暴力枚举 */
// 时间复杂度:O(n^2)   大数据量下非常耗时
// 空间复杂度:O(1)
vector<int> twoSumBruteForce(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 {};
}

4.2 哈希查找:以空间换时间

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

数据结构与算法(七):搜索算法_第4张图片

/* 方法二:辅助哈希表 */
// 时间复杂度:O(n)
// 空间复杂度:O(n)
// 该方法的整体时空效率更为均衡,因此它是本题的最优解法
vector<int> twoSumHashTable(vector<int> &nums, int target) {
    int size = nums.size();
    // 辅助哈希表,空间复杂度 O(n)
    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 {};
}

5. 重识搜索算法

  • 搜索算法用于在数据结构(例如数组、链表、树或图)中搜索一个或一组满足特定条件的元素
  • 搜索算法可根据实现思路分为以下两类
    • 通过遍历数据结构来定位目标元素,例如数组、链表、树和图的遍历等
    • 利用数据组织结构或数据包含的先验信息,实现高效元素查找,例如二分查找、哈希查找和二叉搜索树查找等

5.1 暴力搜索

  • 暴力搜索通过遍历数据结构的每个元素来定位目标元素

    • “线性搜索” 适用于数组和链表等线性数据结构
      • 它从数据结构的一端开始,逐个访问元素,直到找到目标元素或到达另一端仍没有找到目标元素为止
    • “广度优先搜索” 和 “深度优先搜索” 是图和树的两种遍历策略
      • 广度优先搜索从初始节点开始逐层搜索,由近及远地访问各个节点
      • 深度优先搜索是从初始节点开始,沿着一条路径走到头为止,再回溯并尝试其他路径,直到遍历完整个数据结构
  • 暴力搜索的优点是简单且通用性好,无须对数据做预处理和借助额外的数据结构

    • 然而,此类算法的时间复杂度为 O(n),其中 n 为元素数量,因此在数据量较大的情况下性能较差

5.2 自适应搜索

  • 自适应搜索利用数据的特有属性(例如有序性)来优化搜索过程,从而更高效地定位目标元素
    • 二分查找
      • 利用数据的有序性实现高效查找,仅适用于数组
    • 哈希查找
      • 利用哈希表将搜索数据和目标数据建立为键值对映射,从而实现查询操作
    • 树查找
      • 在特定的树结构(例如二叉搜索树)中,基于比较节点值来快速排除节点,从而定位目标元素
  • 此类算法效率高,时间复杂度可达 O(log n) 甚至 O(1)。但使用这些算法前往往需要对数据进行预处理
    • 二分查找需要预先对数组进行排序
    • 哈希查找和树查找都需要借助额外的数据结构
    • 维护这些数据结构也需要额外的时间和空间开支

5.3 搜索方法对比

数据结构与算法(七):搜索算法_第5张图片

数据结构与算法(七):搜索算法_第6张图片

你可能感兴趣的:(数据结构与算法,数据结构,算法,c++,学习,二分查找,暴力搜索,哈希查找)