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.

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / 
 2   3
    /
   4
    
     5

The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

Code:

Simple way (recursive):

class Solution {
public:
    bool isSymmetric(TreeNode *root) {  
      // Start typing your C/C++ solution below  
      // DO NOT write int main() function  
      if(root == NULL) return true;  
      return isSym(root->left, root->right);  
    }  
    bool isSym(TreeNode *left, TreeNode *right)  
    {  
      if(left == NULL)  
        return right ==NULL;  
      if(right == NULL)  
        return left == NULL;  
      if(left->val != right->val)  
        return false;  
      if(!isSym(left->left, right->right))  
        return false;  
      if(!isSym(left->right, right->left))  
        return false;  
      return true;  
    }  
};

Regular way:

class Solution {
public:
    bool checkSymmetric(TreeNode *left, TreeNode *right){
        if(left->left&&right->right){
            if(left->left->val!=right->right->val)
                return false;
            else if(left->right&&right->left&&left->right->val==right->left->val){
                if(checkSymmetric(left->left,right->right))
                    return checkSymmetric(left->right,right->left);
                else
                    return false;
            }else if(!left->right&&!right->left){
                return checkSymmetric(left->left,right->right);
            }else
                return false;
        }else if(left->right&&right->left){
            if(left->right->val!=right->left->val)
                return false;
            else if(!left->left&&!right->right)
                return checkSymmetric(left->right,right->left);
            else
                return false;
        }else if(!left->left&&!right->right&&!left->right&&!right->left){
            return true;
        }else
            return false;
    }
    
    bool isSymmetric(TreeNode *root) {
        if(root){
            if(root->left&&root->right&&root->left->val==root->right->val)
                return checkSymmetric(root->left,root->right);
            else if(!root->left&&!root->right)
                return true;
            else
                return false;
        }else
            return true;
    }
};