代码随想录训练营第14天|递归对称树-优快云博客

226. 翻转二叉树

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr)
            return nullptr;
        auto left=invertTree(root->left);
        auto right=invertTree(root->right);
        root->left=right;
        root->right=left;
        return root;
    }
};

101. 对称二叉树

/**
 * 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 compare(TreeNode* left, TreeNode* right){
        if(left==nullptr&&right==nullptr)
            return true;
        if(left==nullptr&&right)
            return false;
        if(left&&right==nullptr)
            return false;
        if(left->val!=right->val)
            return false;
        return compare(left->left,right->right)&&compare(left->right,right->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr)
            return true;
        return compare(root->left,root->right);        
    }
};

class Solution {
public:
    bool check(vector<int>& s){
        int left=0, right=s.size()-1;
        while(left<right){
            if(s[left++]!=s[right--])
                return false;
        }
        return true;
    }

    bool isSymmetric(TreeNode* root) {
        if(root==nullptr)
            return true;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int n=q.size();
            vector<int> level;
            for(int i=0;i<n;i++){
                auto node=q.front();
                q.pop();
                if(node){
                    level.push_back(node->val);
                    q.push(node->left);
                    q.push(node->right);
                }
                else
                    level.push_back(INT_MAX);                
            }
            if(!check(level))
                return false;
        }
        return true;        
    }
};

层次遍历+回文思想，对于空节点使用INT_MAX占位，解决歧义问题。

104. 二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        int left=maxDepth(root->left);
        int right=maxDepth(root->right);
        return 1+max(left,right);
    }
};

111. 二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr)
            return 0;
        int left=minDepth(root->left);
        int right=minDepth(root->right);
        if(left==0)
            return 1+right;
        if(right==0)
            return 1+left;
        return 1+min(left,right);
    }
};

深度要求到【叶子节点】，不能是空节点，所以对于子树为空的情况额外处理。