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.

/**
 * 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) {
        if (root == null) return true;
        if (root.left == null && root.right == null) return true;
        return isMiror(root.left, root.right);
        
    }
    
    public boolean isMiror(TreeNode n1, TreeNode n2) {
        if (n1 == null && n2 == null) return true;
        if (n1 == null && n2 != null) return false;
        if (n1 != null && n2 == null) return false;
        if (n1.val != n2.val) return false;
        return isMiror(n1.left, n2.right) && isMiror(n1.right, n2.left);
    }
}

Non-recursive solution:

public class Solution {

    public boolean isSymmetric(TreeNode root) {
    if (root == null || root.left == null && root.right == null) return true;
	if (root.left != null && root.right == null) return false;
	if (root.right != null && root.left == null) return false;
	LinkedList<TreeNode> upperLevel = new LinkedList<TreeNode>(); 
    LinkedList<TreeNode> lowerLevel = new LinkedList<TreeNode>();
	TreeNode nullNode = new TreeNode(-1);
	upperLevel.add(root.left);
	upperLevel.add(root.right);

	while (upperLevel.size() != 0) {
		int length = upperLevel.size();
		for (int i = (length - 1) / 2; i >= 0; i--) {
			if (upperLevel.get(i) == nullNode && upperLevel.get(length - i - 1) == nullNode) {

			} else if (upperLevel.get(i).val == upperLevel.get(length - i - 1).val) {
				insertElement(upperLevel.get(i).right, lowerLevel, 0, nullNode);
				insertElement(upperLevel.get(i).left, lowerLevel, 0, nullNode);
				insertElement(upperLevel.get(length - i - 1).left, lowerLevel, nullNode);
				insertElement(upperLevel.get(length - i - 1).right, lowerLevel, nullNode);
			} else {
				return false;
			}			
		}
		LinkedList<TreeNode> temp = upperLevel;
		upperLevel = lowerLevel;
		lowerLevel = temp;
		lowerLevel.clear();
		
	}
	return true;
    }

	public void insertElement(TreeNode node, LinkedList<TreeNode> list, int i, TreeNode nullNode) {
		if (node == null) {
			list.add(i, nullNode);
		} else {
			list.add(i, node);
		}
	}

	public void insertElement(TreeNode node, LinkedList<TreeNode> list, TreeNode nullNode) {
		if (node == null) {
			list.add(nullNode);
		} else {
			list.add(node);
		}
	}
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}