剑指 Offer 28. 对称的二叉树

剑指 Offer 28. 对称的二叉树

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

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

---

思路

递归

一开始想直接用递归，就是，判断root.left是不是对称二叉树，并且root.right是不是对称二叉树
突然发现，这样是错误❌的。
因为，第一个例子已经表明，该树是对称二叉树，而其左子树并不是对称二叉树

中序遍历

通过遍历思想

//前序遍历1 2 3 4 2 4 3 不行
//中序遍历3 2 4 1 4 2 3 行
//后续遍历3 4 2 4 3 2 1 不行
//层序遍历1 2 2 3 4 4 3 不行

可以看出，这种对称二叉树，其中序遍历是对称的

是否可以通过这个特性，来求出是否为对称二叉树

中序遍历，遍历的val存储在一个数组
然后利用双指针，看该数组是否对称
可得如下代码：

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

    ArrayList array = new ArrayList<>();

    public boolean isSymmetric(TreeNode root) {
        //边界条件
        if (root == null) return true;
        
        //前序遍历1 2 3 4 2 4 3 不行
        //中序遍历3 2 4 1 4 2 3 行
        //后续遍历3 4 2 4 3 2 1 不行
        //层序遍历1 2 2 3 4 4 3 不行

        inOrder(root);
        //1 2 2 1
        //1 2 3 2 1

        int left = 0;
        int right = array.size() - 1;

        while (left <= right) {
            if (array.get(left) == array.get(right)){
                left++;
                right--;
            }else{
                return false;
            }
        }

        return true;
    }
		
		//中序遍历
    private void inOrder(TreeNode root) {
        if (root == null) return;
        if (root.left != null) {
            inOrder(root.left);
        }
        
        array.add(root.val);

        if (root.right != null) {
            inOrder(root.right);
        }

    }
}

结果：

    1
   / \
  2   2
 / 	 / 
2   2 

中序遍历：22122
但其明显不是对称二叉树

此方法不对❌

最终做法：

递归判断两棵树是否相等

通过观察可以得知，对称二叉树
树A某一节点的左节点的值，等于树B某一节点的右节点的值
树A某一节点的右节点的值，等于树B某一节点的左节点的值

/**
 * 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 isEqual(root, root);
    }

    //判断两棵树是否相等、一样
    private boolean isEqual(TreeNode A, TreeNode B) {
        if (A == null && B != null) return false;
        if (A != null && B == null) return false;
        if (A == null && B == null) return true;
        if (A.val != B.val) return false;
        
        if (isEqual(A.left, B.right) && isEqual(A.right, B.left)) return true;
        return false;
    }
}