第五部分：二分查找
222.完全二叉树的节点个数（简单）
题目：给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
示例 1：
输入：root = [1,2,3,4,5,6] 输出：6
示例 2：
输入：root = [] 输出：0
第一种思路：
这不是瞧了嘛，刚从递归圈子里出来呢，计算节点个数：
如果本节点为null，则为0
如果有子节点，则为1
然后子节点重复同样的操作
所以很容易得出思路--递归
基本情况：函数开始时检查当前节点
root是否为null. 如果是，说明树没有节点，返回0.递归调用：如果当前节点不为空，递归地计算其左子节点和右子节点的数量。
节点总数计算：
通过
countNodes(root.left)获取左子树的节点数量。通过
countNodes(root.right)获取右子树的节点数量。将两个子树的节点数量相加，并加上
1（代表当前节点本身）。函数返回值：最终返回的值是整颗树中所有节点的数量。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
// 方法：计算二叉树中节点的总数
public int countNodes(TreeNode root) {
// 如果当前节点为空，返回0（递归的基本情况）
if(root == null) return 0;
// 递归计算左子树和右子树的节点数量，然后加上当前节点
// 1. countNodes(root.left) 计算左子树的节点数量
// 2. countNodes(root.right) 计算右子树的节点数量
// 3. +1 是为了计算当前节点自身
return countNodes(root.left) + countNodes(root.right) + 1;
}
}35.搜索插入位置（简单）
题目：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5 输出: 2
示例 2:
输入: nums = [1,3,5,6], target = 2 输出: 1
第一种思路：
复杂度计算：
假设数组的长度为 nn，每次迭代后，待查找的元素数量减少一半。
因此，查找的次数为
（以 2 为底的对数），即
由于二分查找法每次都将搜索范围缩小一半，故其时间复杂度为 O(logn)O(logn)。这使得它在处理大规模数据时非常高效，尤其是在处理已排序的数组时。
采用二分查找法：
定义左右指针：初始化两个指针
left和right分别指向数组的开始和结束。迭代查找：使用
while循环进行二分查找，条件为left <= right。这一点确保了不会错过任何可能的目标值。计算中间索引：在每次迭代中，根据
left和right的值计算中间索引mid。使用left + (right - left) / 2计算方法可以避免潜在的整数溢出问题。比较与调整指针：
如果
nums[mid]小于target，说明目标值可能在右半部分，因此将left指针移动到mid + 1。如果
nums[mid]大于等于target，说明目标值可能在左半部分（或者就是mid），因此将right指针移动到mid - 1。找到插入位置：当循环结束后，
left指针的位置即为target的正确插入位置。如果target在数组中不存在，left将指向应该插入的位置以保持数组的排序。
class Solution {
public int searchInsert(int[] nums, int target) {
// 初始化左右指针
int left = 0;
int right = nums.length - 1;
// 使用二分查找
while (left <= right) { // 当左指针小于等于右指针时进行循环
// 计算中间索引，避免可能的整数溢出
int mid = left + (right - left) / 2;
// 比较中间元素与目标值
if (nums[mid] < target) {
// 如果中间元素小于目标值，移动左指针到中间右边
left = mid + 1;
} else {
// 如果中间元素大于或等于目标值，移动右指针到中间左边
right = mid - 1;
}
}
// 当循环结束时，左指针的位置即为目标值的插入位置
return left; // 返回插入位置
}
}代码注意：！！！！
中间索引计算：在计算
mid时使用了int mid = (right-left)/2;，这是不正确的。正确的计算方式应该是int mid = left + (right - left) / 2;，这样可以确保mid是当前范围内的正确中间点。循环条件问题：在
while循环的条件使用了left < right，这将导致循环在left和right指向同一个元素时提前结束。正确的条件应该是left <= right，这是为了确保在两个指针重合时可以仍然检查那个元素。
278.第一个错误的版本（简单）
题目：你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例 1：
输入：n = 5, bad = 4 输出：4 解释： 调用 isBadVersion(3) -> false 调用 isBadVersion(5) -> true 调用 isBadVersion(4) -> true 所以，4 是第一个错误的版本。
第一种思路： 二分查找的思路还是很容易理解的
定义问题：我们需要找到第一个坏版本。我们用一个API
isBadVersion(version)来判断某个版本是否是坏版本。边界条件：如果版本数量
n小于等于 1，直接返回该版本号，因为它就是答案。初始化二分查找：
左指针
left从 0 开始。右指针
right从n开始。二分查找过程：
计算中间值
mid。如果
mid是坏版本，意味着第一个坏版本可能在mid左侧，包括mid（因此将right更新为mid，这里是和传统的二分查找有些不同的地方）。如果
mid不是坏版本，说明第一个坏版本在mid右侧（更新left为mid + 1）。结束条件：当
left大于right时，循环结束。此时left指向第一个坏版本。返回结果：返回
left，即为找到的第一个坏版本的索引。
/* The isBadVersion API is defined in the parent class VersionControl.
boolean isBadVersion(int version); */
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
// 如果版本总数小于等于1，则直接返回该版本号。
if (n <= 1)
return n;
// 初始化左右指针，左指针指向0，右指针指向n
int left = 0;
int right = n;
// 采用二分查找的方式查找第一个坏版本
while (left <= right) {
// 计算中间版本
int mid = left + (right - left) / 2;
// 检查中间版本是否为坏版本
if (isBadVersion(mid)) {
// 如果中间版本是坏版本，说明第一个坏版本可能在mid及其左边的区间，所以更新右指针
// right = mid - 1; // 传统的二分查找通常这样做
right = mid; // 这里直接将右指针移动到mid，包含mid版本
} else {
// 如果中间版本不是坏版本，则第一个坏版本在mid的右侧，因此更新左指针
left = mid + 1; // 将左指针移动到mid + 1
}
}
// 循环结束时，left会指向第一个坏版本的索引
return left; // 返回第一个坏版本的索引
}
}
4011
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
