题目

给定一个二叉树，检查它是否是镜像对称的。
如下图所示，就是镜像对称的。

摘自LeetCode101

解题方法&代码

递归求解。参照判断两棵二叉树是否相同使用递归方法，这里不在是左子树与左子树比较，右子树与右子树比较，而是比较左子树与右子树，右子树与左子树是否相同。
如图1：
红圈两节点比较之后，分别比较他们的左子树与右子树（绿圈节点）以及右子树与左子树（蓝圈节点）。

图1

public boolean isSymmetric(TreeNode root) {
    if(null == root){
        return true;
    }
    return isMirror(root.left, root.right);
}

public boolean isMirror(TreeNode r1, TreeNode r2){
    //比较两个对称节点是否相同
    if(r1 == null && r2 == null){
        return true;
    }
    if(r1 != null  && r2 == null){
        return false;
    }
    if(r2 != null && r1 == null){
        return false;
    }
    if(r1.val != r2.val){
        return false;
    }
    //当两个对称节点相同的情况下，递归比较左子树与右子树以及右子树与左子树是否是相同
    //如果相同就是镜面对称的
    boolean m1 = isMirror(r1.left, r2.right);
    boolean m2 = isMirror(r1.right, r2.left);
    return m1 && m2;
}

迭代实现。迭代实现就是利用二叉树的层次遍历，每次遍历二叉树的一层，然后判断这一层是否对称，如果对称继续遍历下一层，如果不对称直接返回结果为不对称。
例如：一层遍历的节点结果为：2，3，4，null，null，4，3，2，则是对称的；2，3，4，null，null，4，3，1，则是不对称的。
递归实现代码

public boolean isSymmetric(TreeNode root) {
    if(null == root){
        return true;
    }
    return isSymmetricIte(root);
}

public boolean isSymmetricIte(TreeNode root){
    //定义队列，层次遍历二叉树，从根节点的下一层开始遍历
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.add(root.left);
    queue.add(root.right);
    while(!queue.isEmpty()){
        int size = queue.size();//当前层次包含的节点个数
        TreeNode[] arr = new TreeNode[size];
        //当前层次节点按顺序存入数组中
        for(int i=0; i< size; ++i){
            arr[i] = queue.poll();
            if(null != arr[i]){
                //下一层的节点加入到队列中
                queue.add(arr[i].left);
                queue.add(arr[i].right);
            }
        }
        //判断当前层次节点是否对称
        for(int i=0; i < size/2; ++i){
            if(arr[i] == null && arr[size - 1 - i] != null){
                return false;
            }
            if(arr[i] != null && arr[size - 1 - i] == null){
                return false;
            }
            if(arr[i] != null && arr[size - 1 - i] != null){
                if(arr[i].val !=  arr[size - 1 - i].val){
                    return false;
                }
            }
        }
    }
    //未发现不对称，返回true
    return true;
}