JAVA练习38-对称的二叉树

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

例如，二叉树 [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

分析：

方法1：BFS+List集合

这道题型要我们比较每一层的节点是否是镜像对称的，那么很容易想到广度优先搜索，每遍历一层，我们可以用 List 集合来存储那一层所有节点的值，用 Integer 规范集合，所以遇到值为空的情况就添加空，然后遍历比较 List 集合的值是否镜像对称即可。

时间复杂度：O(n^2)
空间复杂度：O(n) 

/**
 * 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) {
        //空树判断
        if(root == null){
            return true;
        }
        //定义队列储存节点
        Deque<TreeNode> queue = new ArrayDeque<>();
        //入栈头节点
        queue.offerLast(root);
        while(!queue.isEmpty()){
            //记录此层节点数
            int size = queue.size();
            //记录此层所有节点值，包括空值
            List<Integer> list = new ArrayList<>();
            while(size > 0){
                //出栈
                TreeNode node = queue.pollFirst();
                //判断左右节点是否为空
                if(node.left != null){
                    //添加节点值
                    list.add(node.left.val);
                    //入栈
                    queue.offerLast(node.left);
                }else{
                    //节点为空，添加空
                    list.add(null);
                }
                if(node.right != null){
                    list.add(node.right.val);
                    queue.offerLast(node.right);
                }else{
                    list.add(null);
                }
                size--;
            }
            //比较此层节点是否镜像对称
            int len = list.size();
            for(int i = 0; i < len / 2; ++i){
                if(list.get(i) != list.get(len-i-1)){
                    return false;
                }
            }
        }
        return true;
    }
}

方法2：递归

方法1 每遍历一层都要记录一次当前层的所有节点值，浪费时间空间，那有没有一种方法可以直接比较对称的每组节点呢？这时候就让人想到递归，我们可以让每一次递归都可以代表遍历到一个层，只要递归参数是对称的那一组节点就可以了，对称的那一组节点就相当于上一组节点第一个节点的左（右）节点和第二个节点的右（左）节点，这样递归参数条件就都有了，开整！

时间复杂度：O(n)
空间复杂度：O(n) 

/**
 * 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) {
        //空树判断
        if(root == null){
            return true;
        }
        return recur(root.left, root.right);
    }
    public boolean recur(TreeNode left, TreeNode right){
        //都为空返回true
        if(left == null && right == null){
            return true;
        }
        //一个为空一个不为空返回false
        if(left == null || right == null){
            return false;
        }
        //比较两个值，一样则进行下一次递归遍历
        return left.val == right.val && recur(left.left, right.right) && recur(left.right, right.left);
    }
}

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof