数据结构----搜索之二分查找

数据结构----搜索之二分查找

什么是二分查找？

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

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

如上图所示，我们先初始化指针 𝑖 = 0 和 𝑗 = 𝑛 − 1 ，分别指向数组首元素和尾元素，代表搜索区间[0, 𝑛 − 1] 。
请注意，中括号表示闭区间，其包含边界值本身。

接下来，循环执行以下两步：

1. 计算中点索引 𝑚 = ⌊(𝑖 + 𝑗)/2⌋ ，其中 ⌊ ⌋ 表示向下取整操作。
2. 判断 nums[m] 和 target 的大小关系，分为以下三种情况：
   1. 当 nums[m] < target 时，说明 target 在区间 [𝑚 + 1, 𝑗] 中，因此执行 𝑖 = 𝑚 + 1 。
   2. 当 nums[m] > target 时，说明 target 在区间 [𝑖, 𝑚 − 1] 中，因此执行 𝑗 = 𝑚 − 1 。
   3. 当 nums[m] = target 时，说明找到 target ，因此返回索引 𝑚 。

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

值得注意的是，由于 𝑖 和 𝑗 都是 int 类型，因此 𝑖 + 𝑗 可能会超出 int 类型的取值范围。
为了避免大数越界，我们通常采用公式 𝑚 = ⌊𝑖 + (𝑗 − 𝑖)/2⌋ 来计算中点。

/* 二分查找（双闭区间） */
int binarySearch(int[] nums, int target) {
	// 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
	int i = 0, j = nums.length - 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;
}

时间复杂度 𝑂(log 𝑛) ：在二分循环中，区间每轮缩小一半，循环次数为 $Lo{g}_2$𝑛 。

空间复杂度 𝑂(1) ：指针 𝑖 和 𝑗 使用常数大小空间。

区间表示方法

除了上述的双闭区间外，常见的区间表示还有 左闭右开 区间，定义为 [0, 𝑛) ，即左边界包含自身，右边界不包含自身。在该表示下，区间 [𝑖, 𝑗] 在 𝑖 = 𝑗 时为空。

我们可以基于该表示实现具有相同功能的二分查找算法。

/* 二分查找（左闭右开） */
int binarySearchLCRO(int[] nums, int target) {
	// 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素 +1
	int i = 0, j = nums.length;
	// 循环，当搜索区间为空时跳出（当 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;
}

如图所示，在两种区间表示下，二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。
由于 双闭区间 表示中的左右边界都被定义为闭区间，因此指针 𝑖 和 𝑗 缩小区间操作也是对称的。这样更不容易出错，因此一般建议采用“双闭区间”的写法。

优点与局限性

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

• 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 𝑛 = 2²⁰时，线性查找需要 2²⁰ = 1048576 轮循环，而二分查找仅需 $Lo{g}_2$ 2²⁰= 20 轮循环。

• 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。

然而，二分查找并非适用于所有情况，主要有以下原因:

• 二分查找仅适用于有序数据。若输入数据无序，为了使用二分查找而专门进行排序，得不偿失。因为排序算法的时间复杂度通常为 𝑂(𝑛 log 𝑛) ，比线性查找和二分查找都更高。对于频繁插入元素的场景，为保持数组有序性，需要将元素插入到特定位置，时间复杂度为 𝑂(𝑛) ，也是非常昂贵的。

• 二分查找仅适用于数组。二分查找需要跳跃式（非连续地）访问元素，而在链表中执行跳跃式访问的效率较低，因此不适合应用在链表或基于链表实现的数据结构。

• 小数据量下，线性查找性能更佳。在线性查找中，每轮只需要 1 次判断操作；而在二分查找中，需要 1次加法、1 次除法、1 ~ 3 次判断操作、1 次加法（减法），共 4 ~ 6 个单元操作；因此，当数据量 𝑛 较小时，线性查找反而比二分查找更快。

二分查找插入点

二分查找不仅可用于搜索目标元素，还具有许多变种问题，比如搜索目标元素的插入位置。

无重复元素的情况

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

如果想要复用上节的二分查找代码，则需要回答以下两个问题：

问题一： 当数组中包含 target 时，插入点的索引是否是该元素的索引？

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

问题二： 当数组中不存在 target 时，插入点是哪个元素的索引？

进一步思考二分查找过程：当 nums[m] < target 时 𝑖 移动，这意味着指针 𝑖 在向大于等于 target 的元素靠近。同理，指针 𝑗 始终在向小于等于 target 的元素靠近。

因此二分结束时一定有：𝑖 指向首个大于 target 的元素，𝑗 指向首个小于 target 的元素。易得当数组不包含target 时，插入索引为 𝑖 。

/* 二分查找插入点（无重复元素） */
int binarySearchInsertionSimple(int[] nums, int target) {
	int i = 0, j = nums.length - 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;
}

存在重复元素的情况

在上一题的基础上，规定数组可能包含重复元素，其余不变。

假设数组中存在多个 target ，则普通二分查找只能返回其中一个 target 的索引，而无法确定该元素的左边和右边还有多少 target。
题目要求将目标元素插入到最左边，所以我们需要查找数组中最左一个 target 的索引。

初步考虑通过下图所示的步骤实现：

1. 执行二分查找，得到任意一个 target 的索引，记为 𝑘 。
2. 从索引 𝑘 开始，向左进行线性遍历，当找到最左边的 target 时返回。

此方法虽然可用，但其包含线性查找，因此时间复杂度为 𝑂(𝑛) 。当数组中存在很多重复的 target 时，该方法效率很低。现考虑拓展二分查找代码。

如下图所示，整体流程保持不变，每轮先计算中点索引 𝑚 ，再判断 target 和nums[m] 大小关系，分为以下几种情况：

• 当 nums[m] < target 或 nums[m] > target 时，说明还没有找到 target ，因此采用普通二分查找的缩小区间操作，从而使指针 𝑖 和 𝑗 向 target 靠近。

• 当 nums[m] == target 时，说明小于 target 的元素在区间 [𝑖, 𝑚 − 1] 中，因此采用 𝑗 = 𝑚 − 1 来缩小区间，从而使指针 𝑗 向小于 target 的元素靠近。

循环完成后，𝑖 指向最左边的 target ，𝑗 指向首个小于 target 的元素，因此索引 𝑖 就是插入点。








观察以下代码，判断分支 nums[m] > target 和 nums[m] == target 的操作相同，因此两者可以合并。
即便如此，我们仍然可以将判断条件保持展开，因为其逻辑更加清晰、可读性更好。

/* 二分查找插入点（存在重复元素） */
int binarySearchInsertion(int[] nums, int target) {
	int i = 0, j = nums.length - 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;
}

以上代码都是“双闭区间”写法，有兴趣的同学可以自行实现“左闭右开”写法。
总的来看，二分查找无非就是给指针 𝑖 和 𝑗 分别设定搜索目标，目标可能是一个具体的元素（例如 target ），也可能是一个元素范围（例如小于 target 的元素）。

在不断的循环二分中，指针 𝑖 和 𝑗 都逐渐逼近预先设定的目标。最终，它们或是成功找到答案，或是越过边界后停止。

二分查找边界

1. 查找左边界

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

回忆二分查找插入点的方法，搜索完成后 𝑖 指向最左一个 target ，因此查找插入点本质上是在查找最左一个target 的索引。
考虑通过查找插入点的函数实现查找左边界。
请注意，数组中可能不包含 target ，这种情况可能导致以下两种结果：

• 插入点的索引 𝑖 越界。
• 元素 nums[i] 与 target 不相等。

当遇到以上两种情况时，直接返回 −1 即可。

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

2. 查找右边界

那么如何查找最右一个 target 呢？
最直接的方式是修改代码，替换在 nums[m] == target 情况下的指针收缩操作。
代码在此省略，有兴趣的同学可以自行实现。

下面我们介绍两种更加取巧的方法：

1. 复用查找左边界

实际上，我们可以利用查找最左元素的函数来查找最右元素，具体方法为：将查找最右一个 target 转化为查找最左一个 target + 1。

如图所示，查找完成后，指针 𝑖 指向最左一个 target + 1（如果存在），而 𝑗 指向最右一个 target ，因此返回 𝑗 即可。

请注意，返回的插入点是 𝑖 ，因此需要将其减 1 ，从而获得 𝑗。

/* 二分查找最右一个 target */
int binarySearchRightEdge(int[] nums, int target) {
	// 转化为查找最左一个 target + 1
	int i = binary_search_insertion.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;
}

2. 转化为查找元素

我们知道，当数组不包含 target 时，最终 𝑖 和 𝑗 会分别指向首个大于、小于 target 的元素。
因此，如图所示，我们可以构造一个数组中不存在的元素，用于查找左右边界。

• 查找最左一个 target ：可以转化为查找 target - 0.5 ，并返回指针 𝑖 。
• 查找最右一个 target ：可以转化为查找 target + 0.5 ，并返回指针 𝑗 。
  

代码在此省略，值得注意以下两点：

• 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。
• 因为该方法引入了小数，所以需要将函数中的变量 target 改为浮点数类型。

哈希优化策略

在算法题中，我们常通过将线性查找替换为哈希查找来降低算法的时间复杂度。
我们借助一个算法题来加深理解。

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

线性查找：以时间换空间

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

/* 方法一：暴力枚举 */
int[] twoSumBruteForce(int[] nums, int target) {
	int size = nums.length;
	// 两层循环，时间复杂度 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 new int[] { i, j };
		}
	}
	return new int[0];
}

此方法的时间复杂度为 𝑂(𝑛²) ，空间复杂度为 𝑂(1) ，在大数据量下非常耗时。

哈希查找：以空间换时间

考虑借助一个哈希表，键值对分别为数组元素和元素索引。循环遍历数组，每轮执行图所示的步骤。

1. 判断数字 target - nums[i] 是否在哈希表中，若是则直接返回这两个元素的索引。
2. 将键值对 nums[i] 和索引 i 添加进哈希表。

实现代码如下所示，仅需单层循环即可

/* 方法二：辅助哈希表 */
int[] twoSumHashTable(int[] nums, int target) {
	int size = nums.length;
	// 辅助哈希表，空间复杂度 O(n)
	Map<Integer, Integer> dic = new HashMap<>();
	// 单层循环，时间复杂度 O(n)
	for (int i = 0; i < size; i++) {
		if (dic.containsKey(target - nums[i])) {
			return new int[] { dic.get(target - nums[i]), i };
		}
		dic.put(nums[i], i);
	}
	return new int[0];
}

此方法通过哈希查找将时间复杂度从 𝑂(𝑛²) 降低至 𝑂(𝑛) ，大幅提升运行效率。

由于需要维护一个额外的哈希表，因此空间复杂度为 𝑂(𝑛) 。
尽管如此，该方法的整体时空效率更为均衡，因此它是本题的最优解法。

重识搜索算法

搜索算法用于在数据结构（例如数组、链表、树或图）中搜索一个或一组满足特定条件的元素。

搜索算法可根据实现思路分为以下两类:

• 通过遍历数据结构来定位目标元素，例如数组、链表、树和图的遍历等。
• 利用数据组织结构或数据包含的先验信息，实现高效元素查找，例如二分查找、哈希查找和二叉搜索树查找等。

什么是暴力搜索？

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

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

暴力搜索的优点是简单且通用性好，无须对数据做预处理和借助额外的数据结构。
然而，此类算法的时间复杂度为 𝑂(𝑛) ，其中 𝑛 为元素数量，因此在数据量较大的情况下性能较差。

什么是自适应搜索？

自适应搜索是利用数据的特有属性（例如有序性）来优化搜索过程，从而更高效地定位目标元素。
它常被称为查找算法，主要关注在特定数据结构中快速检索目标元素。

• “二分查找”利用数据的有序性实现高效查找，仅适用于数组。
• “哈希查找”利用哈希表将搜索数据和目标数据建立为键值对映射，从而实现查询操作。
• “树查找”在特定的树结构（例如二叉搜索树）中，基于比较节点值来快速排除节点，从而定位目标元素。

此类算法的优点是效率高，时间复杂度可达到 𝑂(log 𝑛) 甚至 𝑂(1) 。
然而，使用这些算法往往需要对数据进行预处理。
例如，二分查找需要预先对数组进行排序，哈希查找和树
查找都需要借助额外的数据结构，维护这些数据结构也需要额外的时间和空间开支。

搜索方法选取

给定大小为 𝑛 的一组数据，我们可以使用线性搜索、二分查找、树查找、哈希查找等多种方法在该数据中搜索目标元素。
各个方法的工作原理如图 所示。

上述几种方法的操作效率与特性如表所示

搜索算法的选择还取决于数据体量、搜索性能要求、数据查询与更新频率等。

线性搜索 ：

• 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
• 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
• 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。

二分查找：

• 适用于大数据量的情况，效率表现稳定，最差时间复杂度为 𝑂(log 𝑛) 。
• 数据量不能过大，因为存储数组需要连续的内存空间。
• 不适用于高频增删数据的场景，因为维护有序数组的开销较大。

哈希查找：

• 适合对查询性能要求很高的场景，平均时间复杂度为 𝑂(1) 。
• 不适合需要有序数据或范围查找的场景，因为哈希表无法维护数据的有序性。
• 对哈希函数和哈希冲突处理策略的依赖性较高，具有较大的性能劣化风险。
• 不适合数据量过大的情况，因为哈希表需要额外空间来最大程度地减少冲突，从而提供良好的查询性能。

树查找：

• 适用于海量数据，因为树节点在内存中是分散存储的。
• 适合需要维护有序数据或范围查找的场景。
• 在持续增删节点的过程中，二叉搜索树可能产生倾斜，时间复杂度劣化至 𝑂(𝑛) 。
• 若使用 AVL 树或红黑树，则各项操作可在 𝑂(log 𝑛) 效率下稳定运行，但维护树平衡的操作会增加额外开销。

总结

• 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
• 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据预处理，但时间复杂度 𝑂(𝑛) 较高。
• 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 𝑂(log 𝑛) 甚至 𝑂(1) ，但通常需要借助额外数据结构。
• 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
• 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
• 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 𝑂(𝑛) 降低至 𝑂(1) 。