对称二叉树(简单)
题目描述
给你一个二叉树的根节点 root , 检查它是否轴对称。
示例 1:
输入:root = [1,2,2,3,4,4,3]
输出:true
示例 2:输入:root = [1,2,2,null,3,null,3]
输出:false
提示:树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100
进阶:你可以运用递归和迭代两种方法解决这个问题吗?
解题思路
要检查一个二叉树是否是轴对称的,我们可以使用递归或迭代的方法。这里提供了两种方法的解题思路和复杂度分析。
1. 递归方法
递归检查子树:我们需要检查左右子树是否对称。对称的定义是:
左子树的左子树与右子树的右子树对称。
左子树的右子树与右子树的左子树对称。
步骤:
基本情况:如果两个子树都为空,则它们是对称的;如果一个子树为空而另一个子树不为空,则它们不是对称的。
递归条件:检查当前两个节点的值是否相等;递归检查左子树的左子树与右子树的右子树;递归检查左子树的右子树与右子树的左子树。
2. 迭代方法
使用队列:可以使用队列来模拟递归检查过程,通过层次遍历来比较每层的节点对称性。步骤:
使用一个队列来存储节点对。
初始时将根节点的左右子节点加入队列。
循环处理队列中的节点对:
从队列中取出一对节点。
如果两个节点都为空,继续下一对节点。
如果一个节点为空而另一个不为空,返回 false。
如果两个节点的值不相等,返回 false。
将节点对的子节点按照对称的方式加入队列。
复杂度分析
1.递归方法
时间复杂度:O(n),其中 n 是树中的节点数。每个节点都被访问一次。
空间复杂度:O(h),其中 h 是树的高度。递归调用的栈深度最大为树的高度。
2. 迭代方法
时间复杂度:O(n),与递归方法相同,每个节点都被访问一次。
空间复杂度:O(n),在最坏情况下,队列中可能存储所有节点,特别是树完全时。
代码实现
package org.zyf.javabasic.letcode.hot100.tree;
import org.zyf.javabasic.letcode.tree.base.TreeNode;
import java.util.LinkedList;
import java.util.Queue;
/**
* @program: zyfboot-javabasic
* @description: 对称二叉树(简单)
* @author: zhangyanfeng
* @create: 2024-08-22 11:15
**/
public class IsSymmetricSolution {
public boolean isSymmetric1(TreeNode root) {
if (root == null) {
return true;
}
return isMirror(root.left, root.right);
}
private boolean isMirror(TreeNode t1, TreeNode t2) {
if (t1 == null && t2 == null) {
return true;
}
if (t1 == null || t2 == null) {
return false;
}
return (t1.val == t2.val) &&
isMirror(t1.right, t2.left) &&
isMirror(t1.left, t2.right);
}
public boolean isSymmetric2(TreeNode root) {
if (root == null) {
return true;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root.left);
queue.offer(root.right);
while (!queue.isEmpty()) {
TreeNode t1 = queue.poll();
TreeNode t2 = queue.poll();
if (t1 == null && t2 == null) {
continue;
}
if (t1 == null || t2 == null) {
return false;
}
if (t1.val != t2.val) {
return false;
}
queue.offer(t1.left);
queue.offer(t2.right);
queue.offer(t1.right);
queue.offer(t2.left);
}
return true;
}
public static void main(String[] args) {
IsSymmetricSolution solution = new IsSymmetricSolution();
// 示例 1: 对称的二叉树
TreeNode root1 = new TreeNode(1);
root1.left = new TreeNode(2);
root1.right = new TreeNode(2);
root1.left.left = new TreeNode(3);
root1.left.right = new TreeNode(4);
root1.right.left = new TreeNode(4);
root1.right.right = new TreeNode(3);
System.out.println("Example 1: " + solution.isSymmetric1(root1)); // 输出: true
// 示例 2: 不对称的二叉树
TreeNode root2 = new TreeNode(1);
root2.left = new TreeNode(2);
root2.right = new TreeNode(2);
root2.left.right = new TreeNode(3);
root2.right.right = new TreeNode(3);
System.out.println("Example 2: " + solution.isSymmetric2(root2)); // 输出: false
// 示例 3: 空树
TreeNode root3 = null;
System.out.println("Example 3: " + solution.isSymmetric2(root3)); // 输出: true
}
}
二叉树的直径(简单)
题目描述
给你一棵二叉树的根节点,返回该树的 直径 。
二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。
两节点之间路径的 长度 由它们之间边数表示。
示例 1:
输入:root = [1,2,3,4,5]
输出:3
解释:3 ,取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2:输入:root = [1,2] 输出:1提示:
树中节点数目在范围 [1, 104] 内
-100 <= Node.val <= 100
解题思路
要找到二叉树的直径,我们需要找到树中任意两个节点之间的最长路径。这个路径的长度由路径中的边数决定,而不是节点数,可以使用深度优先搜索(DFS)的方法:
定义直径:直径是树中两个节点之间最长的路径长度。这个路径可能会经过树的根节点,也可能不会。
DFS 计算深度:
使用 DFS 递归遍历树中的每个节点,同时计算每个节点的左右子树的深度;对于每个节点,计算通过该节点的最长路径长度,即左右子树深度之和;更新全局变量 maxDiameter 以记录当前最大直径。
计算节点的深度:通过递归计算每个节点的左右子树的深度,返回节点的最大深度。
复杂度分析
时间复杂度
计算每个节点的深度:对于树中的每个节点,我们都需要递归地计算其左右子树的深度。每个节点的处理(即计算其左右子树深度和更新最大直径)只需要常数时间。
总时间复杂度:由于每个节点在 DFS 遍历过程中被访问一次,所以时间复杂度是 O(N),其中 NNN 是树中节点的总数。
空间复杂度
递归栈的空间:由于使用了递归 DFS 方法,递归栈的最大深度等于树的高度。对于最坏情况(例如链式树结构),树的高度可能达到 NNN(节点数),此时递归栈的空间复杂度为 O(N)。对于平衡树,递归栈的深度是树的高度,即 O(log N)。
额外空间:除了递归栈外,额外使用的空间主要是 maxDiameter 变量,空间复杂度为 O(1)。
因此,整体的空间复杂度主要由递归栈的深度决定,对于最坏情况下是 O(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:23
**/
public class DiameterOfBinaryTreeSolution {
private int maxDiameter = 0; // 记录最大直径
public int diameterOfBinaryTree(TreeNode root) {
calculateDepth(root);
return maxDiameter;
}
// 计算树的深度并更新最大直径
private int calculateDepth(TreeNode node) {
if (node == null) {
return 0;
}
// 递归计算左右子树的深度
int leftDepth = calculateDepth(node.left);
int rightDepth = calculateDepth(node.right);
// 更新最大直径
maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth);
// 返回当前节点的深度
return Math.max(leftDepth, rightDepth) + 1;
}
public static void main(String[] args) {
DiameterOfBinaryTreeSolution solution = new DiameterOfBinaryTreeSolution();
// 示例 1
TreeNode root1 = new TreeNode(1);
root1.left = new TreeNode(2);
root1.right = new TreeNode(3);
root1.left.left = new TreeNode(4);
root1.left.right = new TreeNode(5);
System.out.println("Example 1: " + solution.diameterOfBinaryTree(root1)); // 输出: 3
// 示例 2
TreeNode root2 = new TreeNode(1);
root2.left = new TreeNode(2);
System.out.println("Example 2: " + solution.diameterOfBinaryTree(root2)); // 输出: 1
}
}
————————————————
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
原文链接:https://blog.csdn.net/xiaofeng10330111/article/details/141401712