目录
【LeetCode | 第三篇】算法笔记
https://blog.csdn.net/h52412224/article/details/158689782?spm=1001.2014.3001.5502【LeetCode | 第二篇】算法笔记https://blog.csdn.net/h52412224/article/details/158467673?spm=1001.2014.3001.5502【LeetCode | 第一篇】算法笔记https://blog.csdn.net/h52412224/article/details/157903186
二叉树
二叉树的中序遍历
思路 1： 递归 法
递归 终止条件 ：当当前节点为 null 时，直接返回（无节点可访问）。
递归 逻辑：
-
先递归遍历当前节点的左子树；
-
访问当前节点（将值加入结果列表）；
-
再递归遍历当前节点的右子树。
java
public class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
inorderHelper(root, result);
return result;
}
private void inorderHelper(TreeNode node, List<Integer> result) {
if (node == null) {
return; // 终止条件：空节点直接返回
}
inorderHelper(node.left, result); // 1. 遍历左子树
result.add(node.val); // 2. 访问根节点
inorderHelper(node.right, result); // 3. 遍历右子树
}
}思路 2：迭代法
初始化一个栈和结果列表，定义指针 curr 指向根节点；
循环条件：curr != null 或栈不为空；
内层循环：将 curr 及其所有左子节点依次压入栈（模拟递归遍历左子树），直到 curr 为 null；
弹出栈顶节点（当前最左节点），访问该节点（加入结果列表）；
将 curr 指向该节点的右子节点（继续遍历右子树）。
java
public class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
Deque<TreeNode> stack = new LinkedList<>(); // 双端队列模拟栈
TreeNode curr = root;
while (curr != null || !stack.isEmpty()) {
// 1. 遍历所有左子节点，压入栈
while (curr != null) {
stack.push(curr);
curr = curr.left;
}
// 2. 弹出栈顶（最左节点），访问
curr = stack.pop();
result.add(curr.val);
// 3. 处理右子树
curr = curr.right;
}
return result;
}
}二叉树的最大深度
思路1： 递归 法
-
递归的核心是将问题分解为子问题：一棵树的最大深度 = 1 + 左子树最大深度与右子树最大深度的较大值。
-
递归终止条件：当节点为
null时，深度为 0（空树无节点）。 -
分别递归计算左、右子树的深度，取最大值加 1 即为当前树的最大深度。
java
public class Solution {
public int maxDepth(TreeNode root) {
// 递归终止：空节点深度为0
if (root == null) {
return 0;
}
// 递归求左子树深度
int leftDepth = maxDepth(root.left);
// 递归求右子树深度
int rightDepth = maxDepth(root.right);
// 当前节点深度 = 左右子树最大深度 + 1
return Math.max(leftDepth, rightDepth) + 1;
}
}思路2：迭代法
-
BFS 按层遍历二叉树，每遍历完整一层，深度加 1，最终层数即为最大深度。
-
初始化队列，将根节点入队，深度初始为 0。
-
循环遍历队列：每次获取当前层节点数量，遍历该层所有节点，将其左右子节点入队；一层遍历完成后深度加 1。
-
队列为空时遍历结束，返回深度。
java
public class Solution {
public int maxDepth(TreeNode root) {
// 空树直接返回0
if (root == null) {
return 0;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root); // 根节点入队
int depth = 0;
while (!queue.isEmpty()) {
// 获取当前层节点个数
int levelSize = queue.size();
// 遍历当前层所有节点
for (int i = 0; i < levelSize; i++) {
TreeNode node = queue.poll();
// 左子节点非空则入队
if (node.left != null) {
queue.offer(node.left);
}
// 右子节点非空则入队
if (node.right != null) {
queue.offer(node.right);
}
}
depth++; // 一层遍历完成，深度+1
}
return depth;
}
}翻转二叉树
思路1： 递归 法
-
递归的核心是交换当前节点的左右子树，再递归处理左右子树。
-
递归终止条件：当前节点为
null，直接返回。 -
交换当前节点的左、右孩子，然后递归翻转左子树、右子树。
java
class Solution {
public TreeNode invertTree(TreeNode root) {
// 递归终止：空节点无需翻转
if (root == null) {
return null;
}
// 交换左右子节点
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
// 递归翻转左子树
invertTree(root.left);
// 递归翻转右子树
invertTree(root.right);
return root;
}
}思路2：迭代法
-
用队列按层遍历二叉树，逐个处理节点。
-
初始化队列，将根节点入队。
-
循环出队：取出节点，交换其左右孩子，再将左右孩子入队。
-
队列为空时遍历结束，返回根节点。
java
class Solution {
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root); // 根节点入队
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
// 交换当前节点左右孩子
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
// 左孩子非空则入队
if (node.left != null) {
queue.offer(node.left);
}
// 右孩子非空则入队
if (node.right != null) {
queue.offer(node.right);
}
}
return root;
}
}对称二叉树
思路：递归法
-
对称二叉树要求：根节点左右子树镜像对称。
-
定义辅助函数判断两个节点是否镜像：
-
两个节点都为
null，返回true。 -
一个为
null一个不为null，返回false。 -
节点值相等，且左节点的左子树与右节点的右子树对称、左节点的右子树与右节点的左子树对称。
-
-
主函数调用辅助函数，传入根节点的左右孩子。
java
class Solution {
public boolean isSymmetric(TreeNode root) {
// 空树对称
if (root == null) {
return true;
}
// 判断左右子树是否镜像
return isMirror(root.left, root.right);
}
// 辅助函数：判断两个节点是否镜像
private boolean isMirror(TreeNode left, TreeNode right) {
// 都为空，对称
if (left == null && right == null) {
return true;
}
// 一个空一个非空，不对称
if (left == null || right == null) {
return false;
}
// 值相等 + 子树镜像
return left.val == right.val
&& isMirror(left.left, right.right)
&& isMirror(left.right, right.left);
}
}二叉树的直径
思路：递归法
-
二叉树直径 = 任意两个节点间最长路径的节点数 - 1（边数）。
-
直径一定是某节点的左子树深度 + 右子树深度。
-
递归计算每个节点的左右子树深度，同时更新全局最大直径。
-
递归返回当前节点的最大深度（供父节点计算）。
java
class Solution {
// 记录最大直径
private int maxDiameter = 0;
public int diameterOfBinaryTree(TreeNode root) {
maxDepth(root);
return maxDiameter;
}
// 递归计算深度，同时更新直径
private int maxDepth(TreeNode node) {
if (node == null) {
return 0;
}
// 左子树深度
int left = maxDepth(node.left);
// 右子树深度
int right = maxDepth(node.right);
// 更新最大直径：左深度 + 右深度
maxDiameter = Math.max(maxDiameter, left + right);
// 返回当前节点最大深度
return Math.max(left, right) + 1;
}
}上述内容也同步在我的飞书，欢迎访问
https://my.feishu.cn/wiki/QLauws6lWif1pnkhB8IcAvkhncc?from=from_copylink
如果我的内容对你有帮助，请点赞，评论，收藏。创作不易，你们的支持就是我坚持下去的动力！