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 = 0; 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);
    }
};