链接
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种基本情况:
序号 | left | right | compare |
---|---|---|---|
1 | null | null | true |
2 | null | right | false |
3 | left | null | false |
4 | left | right | left.val==right.val |
解答思路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
*/
@Test
public 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
*/
@Test
public 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
*/
@Test
public 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);
}
}