一、迭代法

迭代的思路是，层次遍历二叉树，将每一层的节点都获取到（空的也要获取），然后用双指针，从两端到中间对比对称位置的元素是否相等。我这里用的是LinkedList，然后LinkedList可以获取从后往前遍历的迭代器，这样就可以很快速的判断对称位置的元素是否相等了。代码如下：

import java.util.LinkedList;
import java.util.Iterator;
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot==null)
            return true;
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.push(pRoot);
        while (!queue.isEmpty()){
            int levelNum=queue.size();//当前层节点的个数
            //将下一层逐渐弹出
            for (int i=0;i<levelNum;++i){
                //将queue的孩子放入到queue2中
                TreeNode node=queue.remove();
                if (node!=null) {
                    queue.offer(node.left);
                    queue.offer(node.right);
                }else {
                    queue.offer(null);
                    queue.offer(null);
                }
            }
            //从前面往后对比看是否对称
            boolean flag=false;
            Iterator<TreeNode> preIt=queue.listIterator();
            Iterator<TreeNode> postIt=queue.descendingIterator();
            while (preIt.hasNext()&&postIt.hasNext()&&preIt!=postIt){
                TreeNode pre=preIt.next();
                TreeNode post=postIt.next();
                if (pre!=null||post!=null)
                    flag=true;
                if (pre!=null&&post!=null){
                    if (pre.val!=post.val)
                        return false;
                }else if (pre!=post)
                    return false;
            }
            if (!flag)
                break;
        }
        return true;
    }
}

需要注意的是，为了判断对称，我们将空节点也都存了进去，这样为了结束循环，设置了一个flag变量，当队列中的元素都为空时，要跳出循环。

二、递归

递归已经有很多优秀的解答了，我就直接贴代码了：

import java.util.LinkedList;
import java.util.Iterator;
public class Solution {
    boolean isSymmetrical(TreeNode pRoot)
    {
        if (pRoot==null)
            return true;
        return isSymmetrical(pRoot.left,pRoot.right);
    }
    boolean isSymmetrical(TreeNode root1,TreeNode root2){
        if (root1!=null&&root2!=null){
            if (root1.val!=root2.val)
                return false;
            else {
                return isSymmetrical(root1.left,root2.right)
                        &&isSymmetrical(root2.left,root1.right);
            }
        }else if (root1==root2)
            return true;
        else
            return false;
    }
}

三、效率对比

迭代法运行15ms，递归法运行30ms，迭代明显好于递归。占用空间两种方法几乎一样。