每日一题day5：[LeetCode：(二叉树专题)：剑指Offer 55 - II、07、55 - I、28、27、965]

每日一题day5：LeetCode

剑指 Offer 55 - II. 平衡二叉树

剑指 Offer 07. 重建二叉树

剑指 Offer 55 - I. 二叉树的深度

剑指 Offer 28. 对称的二叉树

剑指 Offer 27. 二叉树的镜像

965. 单值二叉树

---

1、剑指 Offer 55 - II. 平衡二叉树

/**
 * 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:
    int GetHigh(TreeNode* root){
        if(root == nullptr) return 0;
        int l = GetHigh(root -> left);
        int r = GetHigh(root -> right);
        return max(l, r) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == nullptr) return true;
        int l = GetHigh(root -> left);
        int r = GetHigh(root -> right);
        return abs(l - r) <= 1 && isBalanced(root -> left) && isBalanced(root -> right);
    }
};

2、剑指 Offer 07. 重建二叉树

/**
 * 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:
    unordered_map<int, int> pa;
    TreeNode* slove(int pos, int s, int e, vector<int>& preorder, vector<int>& inorder){
        if(s > e) return nullptr;
        TreeNode* root = new TreeNode(preorder[pos]);
        int nxt_pos = pa[preorder[pos]];
        root -> left = slove(pos + 1, s, nxt_pos - 1, preorder, inorder);
        root -> right = slove(pos + nxt_pos - s + 1, nxt_pos + 1, e, preorder, inorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int size = preorder.size();
        for(int i = 0; i < size; i++) pa[inorder[i]] = i;
        return slove(0, 0, size - 1, preorder, inorder);
    }
};

3、剑指 Offer 55 - I. 二叉树的深度

/**
 * 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:
    int GetHigh(TreeNode* root){
        if(root == nullptr) return 0;
        int l = GetHigh(root -> left);
        int r = GetHigh(root -> right);
        return max(l, r) + 1;
    }
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int l = GetHigh(root -> left);
        int r = GetHigh(root -> right);
        return max(l, r) + 1;
    }
};

4、剑指 Offer 28. 对称的二叉树

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

5、剑指 Offer 27. 二叉树的镜像

/**
 * 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:
    void slove(TreeNode* root){
        if(root == nullptr) return;
        swap(root -> left, root -> right);
        slove(root -> left);
        slove(root -> right);
    }
    TreeNode* mirrorTree(TreeNode* root) {
        slove(root);
        return root;
    }
};

6、965. 单值二叉树

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

---

2021/3/14完。