101. 对称二叉树（递归法、迭代法）、100. 相同的树、572. 另一棵树的子树

本文链接：https://blog.csdn.net/weixin_41997940/article/details/124443834

题目描述：

给你一个二叉树的根节点 root ，检查它是否轴对称。

解答：

法一：递归法

首先要确定采用什么遍历方式来进行判断，我第一个想法是使用层序遍历，检查每一层的遍历结果翻转后是否相同，但是经过尝试层序遍历难以实现，如[1,2,2,null,3,null,3]这种情况，层序遍历判断错误。

然后思考，判断二叉树对称，其实就是判断其左子树的外层和其右子树的外侧是否相同，其左子树的内侧和其右子树的内侧是否相同，如下图所示：

因此对于左子树进行后序遍历：左右中，右子树进行后序遍历：右左中。

采用递归的方式进行实现：

一层一层进行比较，先比较外侧再比较内侧。

依然是对递归的三要素进行考虑

（1）参数和返回值：参数分别为节点的左右节点，返回值为bool类型，二者是否相同。

bool compare(TreeNode* left, TreeNode* right)

（2）终止条件：

返回比较的结果，一共分为两大类，有NULL节点和无NULL节点。

对于有NULL节点的情况而言，有以下几种：

左节点为NULL，右节点不为NULL返回false；
左节点不为NULL，右节点为NULL返回false；
左右节点均为NULL返回true；

对于无NULL节点，二者比较val，不同返回false。

        // 首先排除空节点的情况
        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;

（3）内部处理逻辑：

无NULL节点且左右节点相同，进行处理。先进行左子树左节点和右子树右节点的比较（外侧），再进行左子树右节点和右子树左节点的比较（内侧）。

        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左

最终代码实现：

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{
            bool out_Result = compare(left->left, right->right);//比较外侧
            bool in_Result = compare(left->right, right->left);//比较内侧
            bool result = out_Result && in_Result;
            return result;
        }

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

法二：迭代法

对于迭代法而言其实已经没有遍历方式了，使用一个队列存储下次需要比较的元素。内部处理方式和递归时基本相同，

对于有NULL节点的情况而言，有以下几种：

左节点为NULL，右节点不为NULL返回false；
左节点不为NULL，右节点为NULL返回false；
左右节点均为NULL使用continue，继续下轮循环（此处注意因为不是递归，必须队空才返回true）；

对于无NULL节点且二者val相同，左节点的左孩子，右节点的右孩子先入队（比较外侧）；左节点的右孩子，右节点的左孩子入队（比较内侧）。

代码实现：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root ==  NULL)
            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 == NULL && right != NULL) return false;
            else if (left != NULL && right == NULL) return false;
            else if (left == NULL && right == NULL) continue;
            else if (left->val != right->val) return false;
            else{
                que.push(left->left);
                que.push(right->right);
                que.push(left->right);
                que.push(right->left);
            }
        }
        return true;
    }
};

100. 相同的树

题目描述：

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

解答：

这道题和对称二叉树的思路类似，稍有不同。此题对于两棵树无需采用不同的遍历方式，直接全部采用先序遍历依次比较即可，依旧采用递归法进行解决。

递归法三要素：

（1）参数和返回值：参数为两个根节点，返回值为是否相同。

（2）终止条件：与101题相似，参考101。

（3）内部处理逻辑：无NULL节点且二者val相同，依次比较两个节点的左节点和右节点。

代码实现：

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

572. 另一棵树的子树

题目描述：

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

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

解答:

和相同的树思路类似，本题中先找到遍历root，找到一个值和subRoot相同的节点，然后比较二者是否是相同的树，一旦得到true直接返回即可。

代码实现：

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == NULL && q == NULL)
            return true;
        else if (p == NULL && q != NULL)
            return false;
        else if (p != NULL && q == NULL)
            return false;
        else if (p->val != q->val)
            return false;
        else
            return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        queue<TreeNode*> que;
        bool result = false;
        if (root) que.push(root);
        while(!que.empty()){
            int size = que.size();
            for (int i = 0; i<size; i++){
                TreeNode* p = que.front();
                if(p->val == subRoot->val){
                    result = isSameTree(p, subRoot);
                    if (result == true) 
                        return result;
                }
                que.pop();
                if (p->left) que.push(p->left);
                if (p->right) que.push(p->right);
            }
        }
        return result;
    }
};