网易对称二叉树（简单）+二叉树的直径（简单）

程颐猛

于 2024-10-04 15:58:32 发布

阅读量547

点赞数 5

文章标签：算法

本文链接：https://blog.csdn.net/CMuhgf7654/article/details/142702785

版权

对称二叉树（简单）

题目描述

给你一个二叉树的根节点 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
}
}