链接

https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/
难度： #简单

题目

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

1/ \2   2/ \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

1/ \2   2\   \3    3

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

限制：0 <= 节点个数 <= 1000

注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/

代码框架

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public boolean isSymmetric(TreeNode root) {}
}

题目解析

二叉树是否对称，
就是查看每一层的节点是否对称，
就是从每一层的左右两边开始，
这两个节点相等，
两个节点的比较过程中，
存在如下的4种基本情况：

解答思路1：
迭代解法，
使用双端队列作为辅助，
按层遍历二叉树，
为了保证二叉树对称，
校验队列中保存每层的节点，
从左右两端的节点开始比较，
保证节点两两相同。

解答思路2：
迭代解法，
使用ArryList作为辅助，
按层遍历二叉树，
为了保证二叉树对称，
校验队列中保存每层的节点，
从左右两端的节点开始比较，
保证节点两两相同。

解答思路3：
递归解法，
比较两个二叉树是否对称，
如果相等，
继续比较其子节点是否对称。

3种解答思路中，
递归解法是最快的0ms,
迭代解法使用ArrayList是1ms,
迭代解法使用队列是最慢的2ms。

测试用例

package edu.yuwen.sowrd.num28.solution;import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;import edu.yuwen.sowrd.entity.TreeNode;
import edu.yuwen.sowrd.num28.sol3.Solution;public class SolutionTest {/*** 二叉树是对称的：*    1*   / \*  2   2* / \ / \*3  4 4  3*/@Testpublic void testCase1() {Solution solution = new Solution();TreeNode node1 = new TreeNode(1);TreeNode node2 = new TreeNode(2);TreeNode node3 = new TreeNode(2);TreeNode node4 = new TreeNode(3);TreeNode node5 = new TreeNode(4);TreeNode node6 = new TreeNode(4);TreeNode node7 = new TreeNode(3);node1.left = node2;node1.right = node3;node2.left = node4;node2.right = node5;node3.left = node6;node3.right = node7;TreeNode root = node1;boolean res = solution.isSymmetric(root);Assertions.assertTrue(res);}/*** 二叉树不是对称的：*    1*   / \*  2   2*   \   \*   3    3*/@Testpublic void testCase2() {Solution solution = new Solution();TreeNode node1 = new TreeNode(1);TreeNode node2 = new TreeNode(2);TreeNode node3 = new TreeNode(2);TreeNode node5 = new TreeNode(3);TreeNode node7 = new TreeNode(3);node1.left = node2;node1.right = node3;node2.right = node5;node3.right = node7;TreeNode root = node1;boolean res = solution.isSymmetric(root);Assertions.assertFalse(res);}/*** 二叉树是不对称的：*    2*   / \*  3   3* / \   \*4   5   4*/@Testpublic void testCase3() {Solution solution = new Solution();TreeNode node1 = new TreeNode(2);TreeNode node2 = new TreeNode(3);TreeNode node3 = new TreeNode(3);TreeNode node4 = new TreeNode(4);TreeNode node5 = new TreeNode(5);TreeNode node6 = null;TreeNode node7 = new TreeNode(4);node1.left = node2;node1.right = node3;node2.left = node4;node2.right = node5;node3.left = node6;node3.right = node7;TreeNode root = node1;boolean res = solution.isSymmetric(root);Assertions.assertFalse(res);}
}

解答1

package edu.yuwen.sowrd.num28.sol1;import java.util.Deque;
import java.util.LinkedList;
import java.util.List;import edu.yuwen.sowrd.entity.TreeNode;public class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}// 双端队列，用于比较两端的元素Deque<TreeNode> dq = new LinkedList<>();dq.offer(root.left);dq.offer(root.right);while (!dq.isEmpty()) {int size = dq.size();// List集合,用于保存当前层的元素List<TreeNode> list = new LinkedList<>();list.addAll(dq);// 校验左右两端开始的元素是否相同for (int i = 0; i < size / 2; i++) {TreeNode left = dq.pollFirst();TreeNode right = dq.pollLast();boolean res = true;// 两个节点都不为null,则比较值是否相等// 考虑null的情况,有一个不为null则必不对称if (left != null && right != null) {res = left.val == right.val;} else if (left != null && right == null) {res = false;} else if (left == null && right != null) {res = false;}// 校验发现不对称if (!res) {return false;}}// 保存当前层的下一层节点for (TreeNode node : list) {if (node == null) {continue;}dq.offer(node.left);dq.offer(node.right);}}// 最终确认二叉树是对称的return true;}
}

解答2

package edu.yuwen.sowrd.num28.sol2;import java.util.ArrayList;
import java.util.List;import edu.yuwen.sowrd.entity.TreeNode;public class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}List<TreeNode> nodes = new ArrayList<>();nodes.add(root.left);nodes.add(root.right);while (!nodes.isEmpty()) {int size = nodes.size();// 校验左右两端开始的元素是否相同for (int i = 0; i < size / 2; i++) {TreeNode left = nodes.get(i);TreeNode right = nodes.get(size - 1 - i);// 两个节点都不为null,则比较值是否相等// 考虑null的情况,有一个不为null则必不对称if (left != null && right != null) {boolean res = left.val == right.val;// 校验发现不对称if (!res) {return false;}} else if (left != null && right == null) {return false;} else if (left == null && right != null) {return false;}}// 获取当前层的下一层List<TreeNode> news = new ArrayList<>();for (TreeNode node : nodes) {if (node == null) {continue;}news.add(node.left);news.add(node.right);}nodes = news;}// 最终确认二叉树是对称的return true;}
}

解答3 推荐

package edu.yuwen.sowrd.num28.sol3;import edu.yuwen.sowrd.entity.TreeNode;public class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}return compare(root.left, root.right);}/*** 比较两个二叉树是否对称，* 如果对称继续比较其子节点*/private boolean compare(TreeNode left, TreeNode right) {// 两个节点都为null,则一定对称// 考虑null的情况,有一个不为null则必不对称if (left == null && right == null) {return true;} else if (left != null && right == null) {return false;} else if (left == null && right != null) {return false;}// 校验发现不对称立即返回，否则继续比较if (left.val != right.val) {return false;}/*** 上面的分支判断可以进一步优化：* else if (left == null || right == null || left.val != right.val) {*   return false;* }*/// 继续比较子节点是否对称，都对称才能确认是对称的return compare(left.left, right.right)&& compare(left.right, right.left);}
}