LeetCode 101. 对称二叉树（二叉树，递归，Java）

题目

给定一个二叉树，检查它是否是镜像对称的。

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

进阶：

你可以运用递归和迭代两种方法解决这个问题吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/symmetric-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

需要注意的地方

1. 获取二叉树镜像的方法
2. 复制一个二叉树的方法
3. 判断两个二叉树是否一样的方法
4. 原来的二叉树在通过镜像操作之后，已不再是原来的二叉树，变成了原来二叉树的镜像，所以需要把原来的二叉树复制保存下来，用作比较是否原二叉树和镜像二叉树一样
5. 对于null的处理

题解

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        TreeNode lastTree = copyTree(root);
        transformLeftRightTree(root);
        // traversideTree(lastTree);
        // System.out.println("分割线");
        // traversideTree(root);
        return isSame(lastTree, root);
    }
    /*
    public void traversideTree(TreeNode root) {
        if(root != null) {
            System.out.println(root.val);
            traversideTree(root.left);
            traversideTree(root.right);
        }
        
    }
    */
    // 判断原来的树和镜像的树一样不一样
    public boolean isSame(TreeNode lastTree, TreeNode root) {
        if(lastTree == null && root == null) {
            return true;
        }
        if(lastTree == null && root != null) {
            return false;
        }
        if(lastTree != null && root == null) {
            return false;
        }
        if(lastTree.val != root.val) {
            return false;
        }
        return isSame(lastTree.left, root.left) && isSame(lastTree.right, root.right);
    }
    // 将原来的树复制保存下来
    public TreeNode copyTree(TreeNode root) {
        TreeNode lastTree = null;
        if(root != null) {
            lastTree = new TreeNode(root.val);
            lastTree.left = copyTree(root.left);
            lastTree.right = copyTree(root.right);
        }
        return lastTree;
    }
    // 获得一个树的镜像
    public void transformLeftRightTree(TreeNode root) {
        if(root == null) {
            return;
        }
        if(root.left == null && root.right == null) {
            return;
        }
        if(root.left == null && root.right != null) {
            root.left = root.right;
            root.right = null;
            transformLeftRightTree(root.left);
            return;
        }
        if(root.right == null && root.left != null) {
            root.right = root.left;
            root.left = null;
            transformLeftRightTree(root.right);
            return;
        }
        if(root.left != null && root.right != null) {
            TreeNode t = root.left;
            root.left = root.right;
            root.right = t;
            transformLeftRightTree(root.left);
            transformLeftRightTree(root.right);
            return;
        }
    }
}