[LeetCode OJ] 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?

 

方法一：递归实现

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 bool canBeSymmetric(TreeNode *p, TreeNode *q)
 {
     if(p==NULL && q==NULL)
         return true;
     if((p==NULL && q!=NULL) || (p!=NULL && q==NULL))
         return false;
         
     if(p->val != q->val)
         return false;
     bool b1 = canBeSymmetric(p->left, q->right);  //若二叉树p和二叉树q对称，则 p 的左子树和 q 的右子树对称
     if(b1==false)
        return false;
     bool b2 = canBeSymmetric(p->right, q->left);  //若二叉树p和二叉树q对称，则 p 的右子树和 q 的左子树对称
     
     return b2;
 
 }
 
class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        
        if(root==NULL)
            return true;
        
        return canBeSymmetric(root->left, root->right);
    }
};

方法二：迭代实现

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 vector<int> PreOrderTraverse(TreeNode *p)  //按根左右的顺序遍历二叉树，迭代实现
 {
     vector<int> result;
     stack<TreeNode*> st;
     
     while(p || !st.empty())
     {
         if(p)
         {
             result.push_back(p->val);
             st.push(p);
             p = p->left;
         }
         else
         {
             result.push_back(0); //用0表示空树
             p = st.top();
             st.pop();
             p = p->right;
         }
     }
     result.push_back(0);
     return result;
 }
 
 vector<int> ReversePreOrderTraverse(TreeNode *p) //按根右左的顺序遍历二叉树，迭代实现
 {
     vector<int> result;
     stack<TreeNode*> st;
     
     while(p || !st.empty())
     {
         if(p)
         {
             result.push_back(p->val);
             st.push(p);
             p = p->right;
         }
         else
         {
             result.push_back(0); //用0表示空树
             p = st.top();
             st.pop();
             p = p->left;
         }
     }
     result.push_back(0);
     return result;
 }
 
 
class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        
        if(root==NULL)
            return true;
        
        vector<int> ivec1 = PreOrderTraverse(root->left);
        vector<int> ivec2 = ReversePreOrderTraverse(root->right);
        
        return ivec1==ivec2;
    }
};

注：

    发现对于两棵完全相同的二叉树，用"#"(方法二中是用整数0，也可以用其他的代替)代替空树，他们的先序遍历序列是完全相同的，

反之也成立，即若两颗二叉树的先序遍历序列（用"#"代替空树）完全相同，那么这两颗二叉树也必然相同。

然而这一事实对于用中序遍历序列则不成立，也就是说若两颗二叉树的中序遍历序列（用"#"代替空树）完全相同，这两颗二叉树不一定相同。举例如下：

  2
 /           的中序遍历序列（左根右）为：  #3#2#            先序遍历序列（根左右）为： 23###          后序遍历序列（左右根）为： ##3#2
3                                                                 
不同                   相同                              不同                           不同

 3
            的中序遍历序列（左根右）为：  #3#2#            先序遍历序列（根左右）为： 3#2##          后序遍历序列（左右根）为： ###23
   2 

这两颗树不同，但他们对应的中序遍历序列却相同。