蚂蚁高频面试：二叉树的最大深度（简单）+翻转二叉树（简单）

最新推荐文章于 2024-11-07 19:52:30 发布

柳永利

最新推荐文章于 2024-11-07 19:52:30 发布

阅读量1.1k

点赞数 7

文章标签：面试职场和发展

本文链接：https://blog.csdn.net/LYLWDFGH4567/article/details/142702598

版权

二叉树的最大深度（简单）

题目描述

给定一个二叉树 root ，返回其最大深度。

二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：3
示例 2：输入：root = [1,null,2] 输出：2

提示：

树中节点的数量在 [0, 104] 区间内。
-100 <= Node.val <= 100

解题思路

递归方法较为简洁直观。它的基本思想是：

对于每个节点，最大深度是其左子树和右子树深度的最大值加上 1。
基础情况是，如果节点为空，则深度为 0。

代码实现

package org.zyf.javabasic.letcode.hot100.tree;

import org.zyf.javabasic.letcode.tree.base.TreeNode;

/**
* @program: zyfboot-javabasic
* @description: 二叉树的最大深度（简单）
* @author: zhangyanfeng
* @create: 2024-08-22 10:51
**/
public class MaxDepthSolution {
// 递归计算二叉树的最大深度
public int maxDepth(TreeNode root) {
if (root == null) {
return 0;
}
// 计算左右子树的深度
int leftDepth = maxDepth(root.left);
int rightDepth = maxDepth(root.right);
// 返回较大深度加上根节点本身
return Math.max(leftDepth, rightDepth) + 1;
}

// 测试主函数
public static void main(String[] args) {
// 构造测试用例
TreeNode root1 = new TreeNode(3);
root1.left = new TreeNode(9);
root1.right = new TreeNode(20);
root1.right.left = new TreeNode(15);
root1.right.right = new TreeNode(7);

TreeNode root2 = new TreeNode(1);
root2.right = new TreeNode(2);

// 创建 Solution 实例并进行测试
MaxDepthSolution solution = new MaxDepthSolution();
int depth1 = solution.maxDepth(root1);
int depth2 = solution.maxDepth(root2);

// 打印结果
System.out.println(depth1); // 输出应为 3
System.out.println(depth2); // 输出应为 2
}
}

翻转二叉树（简单）

题目描述

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：

输入：root = [2,1,3]
输出：[2,3,1]
示例 3：输入：root = [] 输出：[]

提示：

树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

解题思路

定义：翻转二叉树的操作是交换每个节点的左子树和右子树。这个操作从根节点开始，然后递归地进行到每个子节点。递归：

基本情况：如果当前节点为空（root == null），则返回 null。
交换子树：交换当前节点的左子树和右子树。
递归调用：递归地对左子树和右子树进行翻转。
返回节点：返回当前节点（其子树已经翻转）。

复杂度分析

时间复杂度：O(n)。其中 n 是树中的节点数。每个节点都需要访问一次以进行交换和递归操作。因此，时间复杂度是 O(n)。

空间复杂度：O(h)。其中 h 是树的高度。递归调用会消耗栈空间，栈的深度是树的高度。最坏情况下，树是链式结构（即退化为单边树），高度为 n，所以空间复杂度是 O(n)。但对于平衡树，树的高度是 log(n)，因此在平衡树的情况下，空间复杂度是 O(log n)。

代码实现

package org.zyf.javabasic.letcode.hot100.tree;

import org.zyf.javabasic.letcode.tree.base.TreeNode;

/**
* @program: zyfboot-javabasic
* @description: 翻转二叉树（简单）
* @author: zhangyanfeng
* @create: 2024-08-22 11:00
**/
public class InvertTreeSolution {
// 翻转二叉树的递归方法
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;
}

// 打印树的中序遍历（用于验证）
public void printInOrder(TreeNode root) {
if (root != null) {
printInOrder(root.left);
System.out.print(root.val + " ");
printInOrder(root.right);
}
}

// 测试主函数
public static void main(String[] args) {
// 构造测试用例
TreeNode root1 = new TreeNode(4);
root1.left = new TreeNode(2);
root1.right = new TreeNode(7);
root1.left.left = new TreeNode(1);
root1.left.right = new TreeNode(3);
root1.right.left = new TreeNode(6);
root1.right.right = new TreeNode(9);

TreeNode root2 = new TreeNode(2);
root2.left = new TreeNode(1);
root2.right = new TreeNode(3);

TreeNode root3 = null;

// 创建 Solution 实例并进行测试
InvertTreeSolution solution = new InvertTreeSolution();

// 翻转并打印结果
TreeNode invertedRoot1 = solution.invertTree(root1);
TreeNode invertedRoot2 = solution.invertTree(root2);
TreeNode invertedRoot3 = solution.invertTree(root3);

System.out.print("Inverted Tree 1 (InOrder): ");
solution.printInOrder(invertedRoot1); // 输出应为 9 7 6 4 3 2 1
System.out.println();

System.out.print("Inverted Tree 2 (InOrder): ");
solution.printInOrder(invertedRoot2); // 输出应为 3 2 1
System.out.println();

System.out.print("Inverted Tree 3 (InOrder): ");
solution.printInOrder(invertedRoot3); // 输出应为空
System.out.println();
}
}