二叉树 | 8 101. 对称二叉树&572. 另一棵树的子树 *

本文记录的是刷题过程中的重要概念和笔记。如有侵权，请联系删除。

101. 对称二叉树

力扣题目链接(opens new window)
https://leetcode.cn/problems/symmetric-tree/
给定一个二叉树，检查它是否是镜像对称的。

思路

遍历顺序：
只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。
准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

递归法

1. 确定递归函数的参数和返回值：参数自然也是左子树节点和右子树节点 返回值自然是bool类型。
2. 确定终止条件： 情况有：

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称 return false
左右都为空，对称，返回true
左右都不为空，比较节点数值，不相同就return false。此时左右节点不为空，且数值也不相同的情况我们也处理了。

3. 确定单层递归的逻辑
   单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

   比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
   比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
   如果左右都对称就返回true ，有一侧不对称就返回false 。

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

简洁版：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val) return false;
        else return compare(left->left, right->right) && compare(left->right, right->left);

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

迭代法 – 队列

需要比对的节点每组有两个，依次放进队列中进行比较。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root) return true;
        queue<TreeNode*> que;
        // 每两个为一组，放进队列中进行比较
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode* leftPtr = que.front();
            que.pop();
            TreeNode* rightPtr = que.front();
            que.pop();
            // 正难指反，罗列所有可能的正确情况
            // 1:均空
            if(!leftPtr && !rightPtr) continue;
            // 2:均不空且等值
            if(leftPtr && rightPtr && leftPtr->val==rightPtr->val){
                // 每两个一组push
                que.push(leftPtr->left);
                que.push(rightPtr->right);

                que.push(leftPtr->right);
                que.push(rightPtr->left);
            } else {
                // 其他的所有都是错误情况
                return false;
            }
        }
        return true;
    }
};

迭代法 – 栈

是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
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* right=st.top(); st.pop();
            TreeNode* left=st.top(); st.pop();
            if(!left && !right) continue;
            else if(left && right && left->val==right->val){
                st.push(left->left);
                st.push(right->right);
                st.push(right->left);
                st.push(left->right);    
            }else return false;
        }
        return true;
    }
};

类似：572. 另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/subtree-of-another-tree

输入：root = [3,4,5,1,2], subRoot = [4,1,2]
输出：true
输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

思路

把判断是否相同封装为函数，遍历树，如果值相同则进行判断。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        //if(!p && !q) return true;
        queue<TreeNode*> que;
        que.push(p);//maybe nullptr
        que.push(q);

        while(!que.empty()){
            TreeNode* leftNode=que.front(); que.pop();
            TreeNode* rightNode=que.front(); que.pop();
            if(!leftNode&&!rightNode) continue;

            if(leftNode && rightNode && leftNode->val==rightNode->val){
                que.push(leftNode->left);
                que.push(rightNode->left);
                que.push(leftNode->right);
                que.push(rightNode->right);
                continue;
            }

            return false;
        }
        return true;
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        stack<TreeNode*> st;
        if(subRoot==NULL) return true;
        else if(root==NULL) return false;
        st.push(root);
        while(!st.empty()){
            TreeNode* tmp = st.top();
            st.pop();
            if(tmp->val == subRoot->val && isSameTree(tmp,subRoot)){
                return true;
            }
            if(tmp->left) st.push(tmp->left);
            if(tmp->right) st.push(tmp->right);
        }
        return false;
    }
};