5.31二叉树专题（201对称二叉树，572）

本文采用递归写法，还是比较简单的。分情况判断就行

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;
        else return compare(root->left, root->right);
    }

    bool compare(TreeNode* left, TreeNode* right){
        if(left==nullptr && right!=nullptr) return false;
        else if(left!=nullptr && right==nullptr) return false;
        else if(left==nullptr && right==nullptr) return true;
        else if(left->val != right->val) return false;
        else{
            bool inside = compare(left->right, right->left);
            bool outside = compare(left->left, right->right);
            bool all = inside && outside;
            return all;
        }
        
    }
};

递归写法

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        queue que;

        que.push(root->left);
        que.push(root->right);

        while(!que.empty()){
            TreeNode* leftnode = que.front();que.pop();
            TreeNode* rightnode = que.front();que.pop();
            //这里避免操纵空节点，所以加这么多判断
            if(leftnode==nullptr && rightnode!=nullptr) return false;
            else if(leftnode!=nullptr && rightnode==nullptr) return false;
            else if(leftnode==nullptr && rightnode ==nullptr) continue;
            else if(leftnode->val!=rightnode->val) return false;
            

            //这里不用加判断，因为之前把空节点都排除了
            que.push(leftnode->left);
            que.push(rightnode->right);
            que.push(leftnode->right);
            que.push(rightnode->left);
        }
        return true;

    }
};

虽然代码复杂，但是也凭借自己做出来了

class Solution {
public:
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        queue que;
        bool result = false;
        if(root == nullptr) return false;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* tmp = que.front();
                que.pop();
                result = compare(tmp, subRoot);
                if(result) return true;
                if(tmp->left){
                    result = compare(tmp->left, subRoot);
                    que.push(tmp->left);
                }
                if(result) return true;

                if(tmp->right){
                    result = compare(tmp->right, subRoot);
                    que.push(tmp->right);
                }
                if(result) return true;
            }
            
        }

        return false;
    }

    bool compare(TreeNode* left, TreeNode* right){
        if(left == nullptr && right!=nullptr) return false;
        else if(left!=nullptr && right==nullptr) return false;
        else if(left == nullptr && right == nullptr) return true;
        else if(left->val != right->val) return false;
        else{
            bool inside = compare(left->left, right->left);
            bool outside = compare(left->right, right->right);
            bool all = inside && outside;
            return all;
        }
    }

    
};

是用递归法写的。用递归比较，用层序遍历来遍历树。