28. 对称的二叉树

链接

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);
    }
}