🚀 探索100+强大的React Hooks可能性！访问 www.reactuse.com 获取完整文档和MCP支持，或通过 npm install @reactuse/core 安装，让我们丰富的Hook集合为您的React开发效率注入强劲动力！
引言
二分查找（Binary Search）作为计算机科学中最基础且高效的算法之一，广泛应用于各种搜索和排序场景。其核心思想是每次将搜索区间减半，从而在对数时间复杂度内完成查找任务。然而，许多开发者在实现二分查找时，常常会在循环条件的选择上感到困惑：究竟是使用 while (left <= right) 还是 while (left < right)？这两种写法看似只有一字之差，实则蕴含着不同的逻辑设计和适用场景，尤其是在处理边界问题时，它们的表现更是大相径庭。理解这两种写法的本质区别，掌握其各自的优缺点和适用范围，是写出健壮、高效二分查找代码的关键。
本文将深入剖析 while (left <= right) 和 while (left < right) 这两种二分查找实现范式。我们将从它们各自的逻辑设计、初始条件、指针移动策略以及最重要的------循环终止条件入手，详细阐述它们在不同查找任务中的应用。通过具体的代码示例和场景分析，旨在帮助读者彻底厘清这两种写法的内在机制，从而在实际开发中能够游刃有余地选择最合适的二分查找策略。
while (left <= right)：精确查找的直观范式
while (left <= right) 是二分查找中最常见、最符合直觉的实现方式。它将搜索区间定义为一个闭区间 [left, right] ，意味着 left 和 right 指向的元素都包含在当前的搜索范围之内。这种写法主要用于在有序数组中查找一个确切的目标值是否存在，或者找到其任意一个位置。
核心逻辑与初始条件
在这种范式中，我们通常将 left 初始化为数组的第一个元素的索引 0，将 right 初始化为数组的最后一个元素的索引 nums.length - 1。这明确了初始的搜索范围覆盖了整个数组。每次迭代，我们计算中间索引 mid = left + Math.floor((right - left) / 2)，然后比较 nums[mid] 与目标值 target 的关系。
循环条件与指针移动
while (left <= right) 这一循环条件是其核心特征。它意味着只要 left 小于或等于 right，当前的搜索区间 [left, right] 就至少包含一个元素（当 left === right 时，区间包含 nums[left] 这一个元素），因此搜索必须继续。这种设计确保了即使目标值是数组中的唯一元素，或者位于区间的边缘，也能被正确地检查到。
指针的移动策略也与循环条件紧密配合：
if (nums[mid] === target): 如果mid位置的元素恰好是目标值，那么我们找到了，直接返回mid。else if (nums[mid] < target): 如果mid位置的元素小于目标值，说明目标值一定在mid的右侧。由于nums[mid]已经检查过且不等于target，我们可以安全地将其排除在下一次搜索范围之外。因此，我们将left更新为mid + 1，将搜索区间缩小到[mid + 1, right]。else (nums[mid] > target): 如果mid位置的元素大于目标值，说明目标值一定在mid的左侧。同理，nums[mid]也可以被排除。我们将right更新为mid - 1，将搜索区间缩小到[left, mid - 1]。
终止条件：left > right
这种写法的最显著特点在于其终止条件：当循环结束时，left 的值会严格大于 right 。这意味着当前的搜索区间 [left, right] 已经变成了一个空区间，即 left 已经越过了 right。例如，如果 left 是 5 而 right 是 4，那么这个区间就不包含任何元素。此时，如果之前没有找到目标值并返回，就说明目标值在整个数组中不存在，函数将返回 -1。
示例代码：
javascript
/**
* 在有序数组中查找目标值的任意一个位置
* @param {number[]} nums 有序数组
* @param {number} target 目标值
* @returns {number} 目标值的索引，如果不存在则返回 -1
*/
function binarySearchExact(nums, target) {
let left = 0;
let right = nums.length - 1; // 初始搜索区间 [0, nums.length - 1]
while (left <= right) { // 循环条件：区间 [left, right] 仍有效
const mid = left + Math.floor((right - left) / 2); // 计算中间索引
if (nums[mid] === target) {
return mid; // 找到目标值，直接返回
} else if (nums[mid] < target) {
left = mid + 1; // 目标值在右侧，排除 mid
} else { // nums[mid] > target
right = mid - 1; // 目标值在左侧，排除 mid
}
}
// 循环结束时，left > right，搜索区间为空，表示未找到目标值
return -1;
}优缺点分析
优点：
- 直观易懂： 闭区间
[left, right]的概念与日常思维习惯相符，更容易理解。 - 代码简洁： 逻辑清晰，不易出错，尤其适合初学者。
- 通用性强： 能够解决最基本的"查找元素是否存在"的问题。
缺点：
- 不适用于边界查找： 当需要查找目标值的"第一个出现位置"或"最后一个出现位置"时，这种写法会变得复杂。因为它在找到一个
target后就直接返回了，无法继续向左或向右寻找边界。 - 额外判断： 如果目标值不存在，需要额外返回一个特殊值（如
-1）来表示。
尽管存在一些局限性，while (left <= right) 依然是二分查找的基石，理解其工作原理是掌握更复杂二分查找变体的前提。
while (left < right)：边界查找的精妙之道
与 while (left <= right) 不同，while (left < right) 这种范式在二分查找中通常用于查找满足特定条件的边界 ，例如"第一个大于或等于目标值的元素"、"最后一个小于或等于目标值的元素"等。它的核心思想是，在循环过程中，left 和 right 指针会不断逼近，直到它们指向同一个位置，而这个位置就是我们所寻找的边界。
核心逻辑与初始条件
在这种范式下，搜索区间通常被理解为左闭右开的 [left, right) ，或者更准确地说，left 和 right 最终会收敛到同一个点，这个点就是答案。left 通常初始化为 0。right 的初始值则可以灵活选择，可以是 nums.length - 1 (当 right 始终代表一个有效索引，且最终 left 和 right 会指向同一个有效索引时)，也可以是 nums.length (当 right 代表一个"开"边界，最终 left 指向答案，而 right 指向答案的下一个位置时)。重要的是，无论如何初始化，最终 left 和 right 都会在循环结束时重合。
每次迭代，我们同样计算中间索引 mid。然而，与 while (left <= right) 不同的是，mid 位置的元素可能 是答案，因此在缩小搜索范围时，我们不会直接将 mid 排除在外，而是根据条件将 mid 保留在 left 或 right 的新边界中。
循环条件与指针移动
while (left < right) 这一循环条件是其显著特征。它意味着只要 left 严格小于 right，搜索区间 [left, right) 就仍然包含至少一个元素（或 left 和 right 尚未重合），搜索就必须继续。当 left === right 时，循环终止，此时 left (或 right) 指向的就是我们最终找到的边界位置。
指针的移动策略是这种范式的精髓所在，它决定了最终 left 和 right 会收敛到哪个边界：
1. 寻找下界（第一个 >= target 的元素）
mid计算：mid = left + Math.floor((right - left) / 2)(向下取整)。if (nums[mid] >= target):mid位置的元素满足条件，它可能 是第一个>= target的元素，或者答案在mid的左侧。为了找到最左边的那个，我们将right更新为mid。这样mid被保留在了新的搜索区间[left, mid)中。else (nums[mid] < target):mid位置的元素不满足条件（太小了），它肯定不是第一个>= target的元素。因此，我们将left更新为mid + 1，将搜索区间缩小到[mid + 1, right)。
2. 寻找上界（最后一个 <= target 的元素）
mid计算：mid = left + Math.ceil((right - left) / 2)(向上取整，或(left + right + 1) >>> 1)。这里向上取整至关重要，它能避免当left和right相邻且mid等于left时，left = mid导致的死循环。if (nums[mid] <= target):mid位置的元素满足条件，它可能 是最后一个<= target的元素，或者答案在mid的右侧。为了找到最右边的那个，我们将left更新为mid。这样mid被保留在了新的搜索区间[mid, right)中。else (nums[mid] > target):mid位置的元素不满足条件（太大了），它肯定不是最后一个<= target的元素。因此，我们将right更新为mid - 1，将搜索区间缩小到[left, mid - 1)。
终止条件：left === right
与 while (left <= right) 范式中 left > right 的终止条件不同，while (left < right) 范式在循环结束时，left 的值会等于 right 。此时，left (或 right) 所指向的这个位置，就是我们经过不断逼近最终锁定的边界。这个位置可能就是目标值本身，也可能是目标值应该插入的位置，具体取决于查找的类型。
示例代码（寻找第一个 >= target 的元素，即 searchRange 中的 findLeft）：
javascript
/**
* 寻找有序数组中第一个大于或等于目标值的元素的位置
* @param {number[]} nums 有序数组
* @param {number} target 目标值
* @returns {number} 第一个大于或等于目标值的元素的索引，如果所有元素都小于目标值，则返回 nums.length
*/
function findFirstGreaterEqual(nums, target) {
let left = 0;
let right = nums.length - 1; // right 也可以是 nums.length，取决于具体实现和对边界的理解
while (left < right) { // 循环条件：left 严格小于 right
const mid = (left + right) >>> 1; // 向下取整
if (nums[mid] >= target) {
right = mid; // mid 可能是答案，保留 mid，继续向左侧逼近
} else {
left = mid + 1; // mid 太小，肯定不是答案，向右侧移动
}
}
// 循环结束时，left === right，这个位置就是第一个 >= target 的元素
return left;
}优缺点分析
优点：
- 精确查找边界： 能够优雅且精确地找到满足特定条件的第一个或最后一个元素的位置，非常适合解决 LeetCode 中常见的"查找区间"问题。
- 避免额外判断： 循环结束后，
left(或right) 直接就是答案，无需额外的后处理逻辑。
缺点：
- 逻辑复杂性： 相较于
while (left <= right)，这种写法需要更仔细地设计mid的取整方式和指针的移动策略，以避免死循环或错误结果。 - 理解门槛： 对于初学者来说，理解其内部机制（特别是
mid的取整和指针保留mid的逻辑）可能需要更多时间。
尽管实现起来需要更细致的思考，但 while (left < right) 范式在处理复杂二分查找问题时展现出的强大能力和简洁性，使其成为高级二分查找技巧中不可或缺的一部分。
核心区别与选择建议：理解终止条件的深层含义
通过对 while (left <= right) 和 while (left < right) 两种二分查找范式的深入剖析，我们可以清晰地看到它们在设计哲学、适用场景和实现细节上的显著差异。然而，最核心的区别，也是理解这两种范式精髓的关键，在于它们循环终止时 left 和 right 指针的状态。
终止条件的本质差异
| 特性 | while (left <= right) 范式 |
while (left < right) 范式 |
|---|---|---|
| 搜索区间定义 | 闭区间 [left, right] |
左闭右开 [left, right) 或其他灵活定义，但最终 left 和 right 会重合 |
mid 处理 |
mid 确定不是答案时，排除 mid：mid + 1 或 mid - 1 |
mid 可能是答案时，保留 mid：mid 或 mid + 1 |
| 循环终止条件 | left > right |
left === right |
终止时 left 含义 |
无效，表示搜索范围为空 | 最终答案，或答案的插入位置 |
| 适用场景 | 查找确切值是否存在或任意位置 | 查找边界（第一个/最后一个满足条件的元素） |
1. while (left <= right)：left > right，搜索空间耗尽
当 while (left <= right) 循环终止时，left 的值会严格大于 right 。这表示当前的搜索区间 [left, right] 已经彻底为空，不再包含任何元素。如果在此之前没有找到目标值并返回，那么可以断定目标值在整个数组中不存在。这种终止状态非常直观地反映了"搜索失败"或"搜索完成但未找到"的结果。它的设计理念是，每次迭代都将 mid 排除在下一次搜索范围之外，直到搜索空间完全耗尽。
2. while (left < right)：left === right，答案锁定
相反，当 while (left < right) 循环终止时，left 的值会等于 right 。此时，left (或 right) 所指向的这个唯一位置，就是算法经过不断收敛和逼近后锁定的最终答案。这个答案可能是第一个满足条件的元素，也可能是最后一个满足条件的元素，或者是目标值应该插入的位置。这种设计理念是，left 和 right 指针不断向彼此靠拢，直到它们重合于一个点，而这个点就是我们寻找的边界。因此，循环结束后，无需额外的判断，直接返回 left (或 right) 即可。
如何选择：根据任务需求定夺
理解了这两种范式在终止条件上的根本差异，我们就可以根据具体的任务需求，做出明智的选择：
-
当你需要查找一个元素是否存在，或者找到它的任意一个位置时，选择
while (left <= right)。- 理由： 这种写法逻辑最简单，最符合直觉，且能够高效地完成这类任务。它的"搜索空间耗尽"的终止条件，能够清晰地指示查找是否成功。
- 示例： 判断数组中是否包含数字
5。
-
当你需要查找满足某个条件的第一个元素的位置（下界），或者最后一个元素的位置（上界）时，选择
while (left < right)。- 理由： 这种写法通过巧妙的指针移动和
mid的保留策略，能够精确地收敛到边界位置。其"答案锁定"的终止条件，使得循环结束后直接返回left即可得到结果，代码更为简洁和优雅。 - 示例： 在
[1, 2, 3, 3, 3, 4]中查找3的第一个出现位置（索引2）和最后一个出现位置（索引4）。
- 理由： 这种写法通过巧妙的指针移动和
实践中的注意事项
无论选择哪种范式，以下几点是确保二分查找正确性的通用原则：
- 数组必须有序： 二分查找的前提是数据必须是排序的。
mid的计算： 推荐使用mid = left + Math.floor((right - left) / 2)来避免left + right溢出，并确保向下取整。在while (left < right)寻找上界时，可能需要向上取整mid = left + Math.ceil((right - left) / 2)或mid = (left + right + 1) >>> 1来避免死循环。- 边界条件的细致处理： 特别是在
while (left < right)范式中，left和right的初始值以及它们在if/else分支中的更新方式，需要根据具体问题（寻找下界还是上界）进行精确调整，以确保最终left能够收敛到正确的边界。
掌握了这两种二分查找范式的核心区别，特别是它们在终止条件上的不同含义，你将能够更加自信和灵活地应对各种二分查找问题，写出既高效又健壮的代码。
结论
二分查找虽然看似简单，但其实现细节却蕴含着深刻的算法设计思想。while (left <= right) 和 while (left < right) 这两种范式并非孰优孰劣，而是针对不同查找任务的优化选择。它们的根本区别在于对搜索区间的定义、mid 元素的处理方式，以及最终循环终止时 left 和 right 指针所代表的含义。
while (left <= right)是一种"搜索空间耗尽 "的策略，当left > right时循环终止，适用于查找确切值。它直观易懂，是二分查找的入门范式。while (left < right)则是一种"答案锁定 "的策略，当left === right时循环终止，适用于查找边界。它更为灵活和强大，能够精确地定位第一个或最后一个满足条件的元素，是解决复杂二分查找问题的利器。
掌握这两种范式的精髓，特别是理解它们各自的终止条件所带来的不同含义，将使你在面对各种二分查找问题时，能够游刃有余地选择最合适的实现方式，从而写出更高效、更健壮的代码。二分查找的艺术，正是在于对这些细微之处的精准把握。