（树_09）对称二叉树、相同的树

这位大佬写的很好

一、递归三部曲：

1.确定参数列表和返回类型

2.确定递归终止条件

3.确定单层递归的逻辑

 

二、迭代

外侧跟内侧相比较，模拟递归的过程

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [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

递归：

/**
 * 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 compare(TreeNode *left, TreeNode *right)
    {
        if(left == nullptr && right !=nullptr) return false;
        else if(right == nullptr && left != nullptr) return false;
        else if(left == nullptr && right == nullptr) return true;
        else if(left->val != right->val) return false;
        bool outside = compare(left->left, right->right);   //  外侧节点相比较
        bool inside = compare(left->right, right->left);    //  内侧节点相比较
        return outside && inside;
    }
    
    bool isSymmetric(TreeNode* root) {
         if(root == nullptr) return true;
         return compare(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 == nullptr) return true;
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode *left = que.front(); que.pop();
            TreeNode *right = que.front(); que.pop();
            
            if(left == nullptr && right == nullptr) continue; //注意这里不是直接return false,你假设到了第三层那么它是有4个节点的，你不能因为其中两个节点为空就返回不判断了，剩下两个节点在left\right同时为空的情况下，还是要进行判断。
            if( !left || !right || left->val != right->val){
                return false;
            }
            //运行到后面这一行，说明左右节点相等则继续将它们的子节点加入队列进行判断
            que.push(left->left);
            que.push(right->right);
            que.push(left->right);
            que.push(right->left);
        }
        return true;
        
    }
};

栈来迭代：

/**
 * 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 == nullptr) return true;
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty()){
            TreeNode *left = st.top(); st.pop();
            TreeNode *right = st.top(); st.pop();
            
            if(left == nullptr && right == nullptr) continue;
            if( !left || !right || left->val != right->val){
                return false;
            }
            //运行到后面这一行，说明左右节点相等则继续将它们的子节点加入队列进行判断
            st.push(left->left);
            st.push(right->right);
            st.push(left->right);
            st.push(right->left);
        }
        return true;
        
    }
};

相同的树 ：跟上面那题其实是一样的思路，只不过这里是左节点跟左节点，右节点跟右节点比较（上题是左右，右左比较）

/**递归
 * 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 == nullptr && q == nullptr) return true;
       else if(p != nullptr && q == nullptr) return false;
       else if(p == nullptr && q != nullptr) return false;
       else if(p->val != q->val) return false;
       bool left_res = isSameTree(p->left, q->left);
       bool right_res = isSameTree(p->right, q->right);
       return left_res && right_res; 
    }
};

栈来迭代：

/**栈来迭代
 * 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 == nullptr && q == nullptr) return true;
       if(p == nullptr || q == nullptr || p->val != q->val){
           return false;
       }
       stack<TreeNode*> st;
       st.push(p);
       st.push(q);
       while(!st.empty()){
           TreeNode *left = st.top(); st.pop();
           TreeNode *right = st.top(); st.pop();
           if(left == nullptr && right == nullptr) continue;
           if(left == nullptr || right == nullptr || left->val != right->val){
               return false;
           }
           st.push(left->left);
           st.push(right->left);
           st.push(left->right);
           st.push(right->right);
       }
       return true;

    }
};

队列来迭代：

/**对列来迭代
 * Definition for a binary tree node.
 * queruct 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 == nullptr && q == nullptr) return true;
       if(p == nullptr || q == nullptr || p->val != q->val){
           return false;
       }
       queue<TreeNode*> que;
       que.push(p);
       que.push(q);
       while(!que.empty()){
           TreeNode *left = que.front(); que.pop();
           TreeNode *right = que.front(); que.pop();
           if(left == nullptr && right == nullptr) continue;
           if(left == nullptr || right == nullptr || left->val != right->val){
               return false;
           }
           que.push(left->left);
           que.push(right->left);
           que.push(left->right);
           que.push(right->right);
       }
       return true;

    }
};