LeetCode 101 100 对称二叉树 相同的树（树 深度优先搜索）

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