剑指offer——对称的二叉树（好）

题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

思路：
{8,6,6,5,7,7,5} 这样的二叉树就是镜像的。

---

测试用例:
{5,5,5,5,#,#,5,5,#,5}
对应输出应该为:
false
你的输出为:
true

错误部分：
一开始只考虑把非空子节点放入队列中，但这样就无法得到空节点对子树结构的影响。所以上述用例会判错！

        while(left.size()!=0&&right.size()!=0){
            temp1 = left.poll();
            temp2 = right.poll();
            if(temp1.val!=temp2.val)
                return false;
            if(temp1.left!=null)
                left.offer(temp1.left);
            if(temp1.right!=null)
                left.offer(temp1.right);
            if(temp2.right!=null)
                right.offer(temp2.right);
            if(temp2.left!=null)
                right.offer(temp2.left);
        }
}    

    boolean isSymmetrical(TreeNode pRoot) {
        // 两个特殊情况
        if (pRoot == null)
            return true;
        if (pRoot.right == null && pRoot.left == null)
            return true;
        //创建两个队列，分别存放root节点的左右子树，LinkedList允许null作为对象，这个特性在此题中很重要
        LinkedList<TreeNode> left = new LinkedList();
        LinkedList<TreeNode> right = new LinkedList();
        left.offer(pRoot.left);
        right.offer(pRoot.right);
        TreeNode temp1;
        TreeNode temp2;
        while (left.size() != 0 && right.size() != 0) { // 有一个size为0就退出循环，否则下面的poll方法会报错
            temp1 = left.poll();
            temp2 = right.poll();
            if (temp1 == null && temp2 != null || temp1 != null && temp2 == null) // 两个元素有一个是null，肯定不对称
                return false;
            else if (temp1 != null && temp2 != null && temp1.val != temp2.val) // 元素值不一样，肯定不对称
                return false;
            // 根据镜像的概念：左子树，先放左节点再放右节点；右子树，先放右节点，再放左节点。
            if (temp1 != null) {
                left.offer(temp1.left);
                left.offer(temp1.right);
            }
            if (temp2 != null) {
                right.offer(temp2.right);
                right.offer(temp2.left);
            }
        }
        if (left.size() != right.size()) // 如果退出循环时，两者的大小不同，则肯定是false
            return false;
        return true;
    }

剑指offer：
定义一种新的前序遍历方式，先遍历右节点，再遍历左节点。并使用递归。

我这个思路的递归版本：

public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if(pRoot == null){
            return true;
        }
        return comRoot(pRoot.left, pRoot.right);
    }
    private boolean comRoot(TreeNode left, TreeNode right) {
        // TODO Auto-generated method stub
        if(left == null) 
            return right==null;
        if(right == null) // 因为此时left！=null，所以如果right=null，直返false
            return false;
        if(left.val != right.val) return false;
        return comRoot(left.right, right.left) && comRoot(left.left, right.right);
    }
}