Symmetric Tree

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

    1
   / 
  2   2
 /  / 
3  4 4  3

But the following is not:

    1
   / 
  2   2
      
   3    3

Note:
Bonus points if you could solve it both recursively and iteratively.

Iterative function:

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean isSymmetric(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        LinkedList<TreeNode> left = new LinkedList<TreeNode>();
        LinkedList<TreeNode> right = new LinkedList<TreeNode>();
        if(root == null) return true;
        else if(root.left == null && root.right == null) return true;
        else if((root.left == null && root.right != null) 
　　　　　　　　　|| (root.left != null && root.right == null)) return false;
        else{
            left.add(root.left);
            right.add(root.right);
            while(!left.isEmpty() && !right.isEmpty()){
                TreeNode l = left.pop();
                TreeNode r = right.pop();
                if(l.val != r.val) return false;
                if(l.left != null && r.right != null){
                    left.add(l.left);
                    right.add(r.right);
                }else if((l.left != null && r.right == null) 
　　　　　　　　　　　　　　 || (l.left == null && r.right != null)){
                    return false;
                }
                if(l.right != null && r.left != null){
                    left.add(l.right);
                    right.add(r.left);
                }else if((l.right != null && r.left == null) 
　　　　　　　　　　　　　　 || (l.right == null && r.left != null)){
                    return false;
                }
            }
        }
        return true;
    }
    
    public void checkNode(){
        
    }
}

Recursive function:

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    boolean rsl = true;
    public boolean isSymmetric(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        rsl = true;
        if(root == null) return rsl;
        else{
            checkNode(root.left,root.right);
        }
        return rsl;
    }
    
    public void checkNode(TreeNode l, TreeNode r){
        if(l == null && r == null ){
            return;
        }else if((l == null && r != null) || (l != null && r == null)){
            rsl = false;
            return;
        }else{
            checkNode(l.left, r.right);
            checkNode(l.right,r.left);
            if(l.val != r.val)rsl =false;
            return;
        }
    }
}

 第二遍：

public class Solution {
    public boolean isSymmetric(TreeNode root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        return root == null || compare(root.left, root.right);
    }
    public boolean compare(TreeNode t1, TreeNode t2){
        if(t1 == null && t2 == null) return true;
        else if((t1 == null || t2 == null) || (t1.val != t2.val))return false;
        else return compare(t1.left, t2.right) && compare(t1.right, t2.left);
    }
}