leetcode-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}".

递归解法：只要递归地判断两个节点为根的子树是否对称即可。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if (root==NULL)
            return true;
        if (isTwoTreeSymmetric(root->left, root->right))
            return true;
        return false;
    }
    
    bool isTwoTreeSymmetric(TreeNode *t1, TreeNode *t2) {
        if (t1==NULL && t2==NULL)
            return true;
        if ((t1&&t2==NULL) || (t1==NULL&&t2))
            return false;
        if (t1->val != t2->val)    //值不相等返回false
            return false;
        if (!isTwoTreeSymmetric(t1->left, t2->right))   //递归比较两个位置对称的子树
            return false;
        if (!isTwoTreeSymmetric(t1->right, t2->left))
            return false;
        return true;
    }
};

非递归（迭代）解法：我们知道递归一般都可以用栈来模拟，所以这道题也可以用栈来解决，思路是把两个要比较的子树根节点指针放入栈中，然后取出两个节点指针，判断是否相等，左右孩子是否对称，如果不是就是不对称，否则再把要比较的所有两个孩子指针放入栈中，不断入栈出栈。

class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        if (root==NULL)
            return true;
        if ((root->left==NULL&&root->right) || (root->left&&root->right==NULL)) //只有一个孩子
            return false;
        if (root->left==NULL && root->right==NULL)  //左右孩子为空
            return true;
            
        stack<TreeNode*> s;
        s.push(root->left);
        s.push(root->right);
        
        TreeNode *tn1, *tn2;
        while (!s.empty()) {
            tn1 = s.top();    //左孩子
            s.pop();
            
            tn2 = s.top();   //右孩子
            s.pop();
            
            if (tn1->val != tn2->val)
                return false;
            
            if ((tn1->left==NULL&&tn2->right) || (tn1->left&&tn2->right==NULL))
                return false;
                
            if ((tn1->right==NULL&&tn2->left) || (tn1->right&&tn2->left==NULL))
                return false;
            
            if (tn1->left) {
                s.push(tn1->left);
                s.push(tn2->right);
            }
            
            if (tn1->right) {
                s.push(tn1->right);
                s.push(tn2->left);
            }
        }
        
        return true;
    }
};