101. Symmetric Tree

原题链接：https://leetcode.com/problems/symmetric-tree/description/

我的思路

这道题目大意是判断一颗二叉树是否是对称树，我看题目是“Easy”级别的，以为不难呢！然后我写出来如下实现：

import java.util.Stack;

/**
 * Created by clearbug on 2018/2/26.
 */
public class Solution {

    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);

        TreeNode rootLeft = new TreeNode(2);
        TreeNode rootRight = new TreeNode(3);
        root.left = rootLeft;
        root.right = rootRight;

        TreeNode leftLeft = new TreeNode(3);
        TreeNode leftRight = null;
        rootLeft.left = leftLeft;
        rootLeft.right = leftRight;

        TreeNode rightLeft = new TreeNode(2);
        TreeNode rightRight = null;
        rootRight.left = rightLeft;
        rootRight.right = rightRight;

        Solution s = new Solution();
        System.out.println(s.isSymmetric(root));
    }

    public boolean isSymmetric(TreeNode root) {
        Stack<Integer> valStack = new Stack<>();
        inOrderTraverse(root, valStack);
        if (valStack.size() == 1) {
            return true;
        }

        Integer[] valArr = new Integer[valStack.size()];
        valStack.toArray(valArr);
        int index = valArr.length / 2;
        while (index >= 0) {
            if (valArr[index] == null) {
                if (valArr[valArr.length - 1 - index] != null) {
                    return false;
                }
            } else if (!valArr[index].equals(valArr[valArr.length - 1 - index])) {
                return false;
            }
            index--;
        }
        return true;
    }

    public void inOrderTraverse(TreeNode node, Stack<Integer> stack) {
        if (node == null) {
            stack.push(null);
            return;
        }

        if (node.left == null && node.right == null) {
            stack.push(node.val);
            return;
        }

        inOrderTraverse(node.left, stack);
        stack.push(node.val);
        inOrderTraverse(node.right, stack);
    }
}

大致想法就是利用中序遍历，然后将遍历的节点值放入栈中，最后将栈转化为一个一维数组，然后对比数组里对称位置上的值是否一致！
初看这个思路是没问题，但是总是有些测试用例运行时失败了。。。看来是我想错了，那就去看看官方答案吧！

官方方法一：递归

不得不说官方答案就是高端大气上档次啊！利用了镜子反射原理+递归实现了，代码也是极其简洁。就是镜子反射原理我还是不大能彻底理解啊：

/**
 * Created by clearbug on 2018/2/26.
 */
public class Solution {

    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);

        TreeNode rootLeft = new TreeNode(2);
        TreeNode rootRight = new TreeNode(3);
        root.left = rootLeft;
        root.right = rootRight;

        TreeNode leftLeft = new TreeNode(3);
        TreeNode leftRight = null;
        rootLeft.left = leftLeft;
        rootLeft.right = leftRight;

        TreeNode rightLeft = new TreeNode(2);
        TreeNode rightRight = null;
        rootRight.left = rightLeft;
        rootRight.right = rightRight;

        Solution s = new Solution();
        System.out.println(s.isSymmetric(root));
    }

    public boolean isSymmetric(TreeNode root) {
        return isMirror(root, root);
    }

    public boolean isMirror(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) {
            return true;
        }
        if (t1 == null || t2 == null) {
            return false;
        }
        return (t1.val == t2.val) && isMirror(t1.right, t2.left) && isMirror(t1.left, t2.right);
    }

}

官方方法二：迭代

这个方法主要还是利用了镜子反射原理，外加队列以及类似 BFS 的思路来实现的：

public boolean isSymmetric(TreeNode root) {
    Queue<TreeNode> q = new LinkedList<>();
    q.add(root);
    q.add(root);
    while (!q.isEmpty()) {
        TreeNode t1 = q.poll();
        TreeNode t2 = q.poll();
        if (t1 == null && t2 == null) continue;
        if (t1 == null || t2 == null) return false;
        if (t1.val != t2.val) return false;
        q.add(t1.left);
        q.add(t2.right);
        q.add(t1.right);
        q.add(t2.left);
    }
    return true;
}