1. 對稱二叉樹

難度：簡單
給定一個二叉樹，檢查它是否是映象對稱的。

例如，二叉樹 [1,2,2,3,4,4,3] 是對稱的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面這個 [1,2,2,null,3,null,3] 則不是映象對稱的:

    1
   / \
  2   2
   \   \
   3    3

說明:
如果你可以運用遞迴和迭代兩種方法解決這個問題，會很加分。
思路：這題其實感覺還蠻難的，沒有用遞迴，單純用了迭代，主要是分為倆條支路 (也是廣度優先搜尋的思想)，root->left下的各路徑的值, root->right下的各路徑的值, 判斷每條路徑值是否一致，如果一致則說明對稱，判斷的條件比較多。

/**
 * 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 isSymmetric(TreeNode* root) {
         if(root==NULL || root->left==NULL && root->right==NULL) return true;
         if(root->left==NULL && root->right!=NULL || root->left!=NULL && root->right==NULL) return false;
         bool isSubpath=subPath(root->left,root->right);
         if(root->left->val==root->right->val && isSubpath){
             return true;
         }
         else return false;
    }
    
    bool subPath(TreeNode *root1, TreeNode* root2){
       vector<int> pathVal1;
       vector<int> pathVal2;
       stack<TreeNode *> stack1;
       stack<TreeNode *> stack2;
       while(root1 ||root2 || !stack1.empty() || !stack2.empty()){
           while(root1 || root2){
               stack1.push(root1);
               stack2.push(root2);
               if((root1==NULL && root2!=NULL) || (root1!=NULL && root2==NULL)){
                   return false;
               }
               pathVal1.push_back(root1->val);
               pathVal2.push_back(root2->val);
               root1=root1->left;
               root2=root2->right;
               if(pathVal1!=pathVal2 || (root1==NULL && root2!=NULL) || (root1!=NULL && root2==NULL)){
                   return false;
               }
           }
           if(!stack1.empty() || !stack2.empty()){
               root1=stack1.top()->right;
               root2=stack2.top()->left;
               pathVal1.pop_back();
               pathVal2.pop_back();
               stack1.pop();
               stack2.pop();
           }
       }
        return true;
    }
};
 

2. 相同的樹

難度：簡單

給定兩個二叉樹，編寫一個函式來檢驗它們是否相同。

如果兩個樹在結構上相同，並且節點具有相同的值，則認為它們是相同的。

示例 1:
輸入:

    1        1
  / \       /  \
 2   3     2   3
[1,2,3],   [1,2,3]

輸出: true

示例 2:
輸入:

      1          1
      /           \
     2             2
   [1,2],     [1,null,2]

輸出: false

示例 3:
輸入:

   1         1
  / \       / \
 2   1     1   2
[1,2,1],   [1,1,2]
 

輸出: false

思路：檢查各支路是否相同，包括值和結構。

/**
 * 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) {
       vector<int> pathVal1;
       vector<int> pathVal2;
       stack<TreeNode *> stack1;
       stack<TreeNode *> stack2;
       while(p || q ||!stack1.empty() ||!stack2.empty()){
           while(p || q){
               stack1.push(p);
               stack2.push(q);
               if((p==NULL && q!=NULL) || (p!=NULL && q==NULL)){
                   return false;
               }
               pathVal1.push_back(p->val);
               pathVal2.push_back(q->val);
               p=p->left;
               q=q->left;
               if(pathVal1!=pathVal2 || (p==NULL && q!=NULL) || (p!=NULL && q==NULL)){
                   return false;
               }
           }
           if(!stack1.empty() || !stack2.empty()){
               p=stack1.top()->right;
               q=stack2.top()->right;
               pathVal1.pop_back();
               pathVal2.pop_back();
               stack1.pop();
               stack2.pop();
           }
       }
        return true;
    }
};

看到網上有大神用遞迴來做的，程式碼非常簡潔，mark學習下：

class Solution {
public:
    bool isSameTree(TreeNode *p, TreeNode *q) {
        if (!p && !q) return true;
        if ((p && !q) || (!p && q) || (p->val != q->val)) return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};