第五部分:二分查找
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; // 返回第一个坏版本的索引
}
}