LeetCode-101.对称二叉树（相关话题：递归/迭代）

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

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

Java代码：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(null == root)
            return true;

        return isSymmetric(root.left, root.right);
    }
    private boolean isSymmetric(TreeNode p, TreeNode q){
        if(null == p && null == q)
            return true;
        if((null == p && null != q) || (null != p && null == q))
            return false;

        return p.val == q.val && isSymmetric(p.left, q.right) && isSymmetric(p.right, q.left);
    }
}

2.迭代

左子树用栈按照左->中->右的顺序，右子树用栈按照右->中->左的顺序，同时遍历，遍历过程中，输出的两个元素不相同，则return false；

遍历完成，若两个栈都为空，return true，否则return false

Java代码：

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(null == root || (null == root.left && null == root.right))
            return true;
        TreeNode p = root.left, q = root.right;
        if((null == p && null != q) || (null != p && null == q) || p.val != q.val)
            return false;

        Stack<TreeNode> leftStack = new Stack<>();
        Stack<TreeNode> rightStack = new Stack<>();
        while(null != p){
            leftStack.push(p);
            p = p.left;
        }
        while(null != q){
            rightStack.push(q);
            q = q.right;
        }

        while(!leftStack.isEmpty() && !rightStack.isEmpty()){
            p = leftStack.pop();
            q = rightStack.pop();
            if(p.val != q.val)
                return false;

            if(null != p.right){
                leftStack.push(p.right);
                while(null != leftStack.peek().left)
                    leftStack.push(leftStack.peek().left);
            }
            if(null != q.left){
                rightStack.push(q.left);
                while(null != rightStack.peek().right)
                    rightStack.push(rightStack.peek().right);
            }
        }

        return leftStack.isEmpty() && rightStack.isEmpty();
    }
}