LeetCode之“树”：Symmetric Tree && Same Tree

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

　　本题暂用递归解法，具体程序（4ms）如下：

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     void updateLVec(TreeNode *left, vector<int>& lVec)
     {
         if(left)
         {
             lVec.push_back(left->val);
             if(left->left || left->right)
             {
                 if(left->left)
                     updateLVec(left->left, lVec);
                 else
                     lVec.push_back(INT_MIN);
                 if(left->right)
                     updateLVec(left->right, lVec);
                 else
                     lVec.push_back(INT_MIN);
             }
         }
     }

     void updateRVec(TreeNode *right, vector<int>& rVec)
     {
         if(right)
         {
             rVec.push_back(right->val);
             if(right->left || right->right)
             {
                 if(right->right)
                     updateRVec(right->right, rVec);
                 else
                     rVec.push_back(INT_MIN);
                 if(right->left)
                     updateRVec(right->left, rVec);
                 else
                     rVec.push_back(INT_MIN);
             }
         }
     }

     bool isSymmetric(TreeNode* root) {
         if(!root || (!root->left && !root->right))
             return true;

         if((!root->left && root->right) || (root->left && !root->right))
             return false;

         vector<int> lVec, rVec;
         updateLVec(root->left, lVec);
         updateRVec(root->right, rVec);

         int szLVec = lVec.size();
         int szRVec = rVec.size();
         if(szLVec != szRVec)
             return false;

         for(int i = ; i < szLVec; i++)
         {
             if(lVec[i] != rVec[i])
                 return false;
         }

         return true;
     }
 };

　　虽然最终解决了问题，但代码还是复杂了。别人的代码（4ms）真叫一个简单呐：

 bool isSymmetric(TreeNode *root)
 {
     if (!root) return true;
     return isSymmetric(root->left, root->right);
 }
 bool isSymmetric(TreeNode *lt, TreeNode *rt)
 {
     if (!lt && !rt) return true;
     if (lt && !rt || !lt && rt || lt->val != rt->val) return false;
     return isSymmetric(lt->left, rt->right) && isSymmetric(lt->right, rt->left);
 }

Same Tree

　　题目链接

　　题目要求：

　　Given two binary trees, write a function to check if they are equal or not.

　　Two binary trees are considered equal if they are structurally identical and the nodes have the same value.

　　有了上一道题的基础，这道题就很简单了，具体程序（0ms）如下：

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     bool isSameTree(TreeNode* p, TreeNode* q) {
         if(!p && !q)
             return true;
         return isSameTreeSub(p, q);
     }

     bool isSameTreeSub(TreeNode *lt, TreeNode *rt)
     {
         if(!lt && !rt)
             return true;
         if((!lt && rt) || (lt && !rt) || (lt->val != rt->val))
             return false;
         return isSameTree(lt->left, rt->left) && isSameTree(lt->right, rt->right);
     }
 };