春节刷题day11：[LeetCode：剑指Offer 27、55、54、68、32、55、28]

春节刷题day11：LeetCode

剑指 Offer 27. 二叉树的镜像

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

剑指 Offer 54. 二叉搜索树的第k大节点

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

剑指 Offer 32 - II. 从上到下打印二叉树 II

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

剑指 Offer 28. 对称的二叉树

---

1、剑指 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 == NULL) return ;
        swap(root -> left, root -> right);
        mirrorTree(root -> left);
        mirrorTree(root -> right);
    }
    TreeNode* mirrorTree(TreeNode* root) {
        slove(root);
        return root;
    }
};

/**
 * 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:
    TreeNode* mirrorTree(TreeNode* root) {
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode* now = st.top(); st.pop();
            if(now == NULL) continue;
            swap(now -> left, now -> right);
            st.push(now -> left);
            st.push(now -> right);
        }
        return root;
    }
};

2、剑指 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 maxDepth(TreeNode* root) {
        if(root == NULL) return 0;
        int l = maxDepth(root -> left);
        int r = maxDepth(root -> right);
        return max(l, r) + 1;
    }
};

/**
 * 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 maxDepth(TreeNode* root) {
        int ans = -1;
        stack<TreeNode*> st;
        if(root == NULL) return 0;
        root -> val = 1;
        st.push(root);
        while(!st.empty()){
            TreeNode* now = st.top(); st.pop();
            ans = max(ans, now -> val);
            if(now -> left){
                now -> left -> val = now -> val + 1;
                st.push(now -> left);
            }
            if(now -> right){
                now -> right -> val = now -> val + 1;
                st.push(now -> right);
            }
        }
        return ans;
    }
};

3、剑指 Offer 54. 二叉搜索树的第k大节点

/**
 * 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 kthLargest(TreeNode* root, int k) {
        queue<TreeNode*> que; que.push(root);
        vector<int> v;
        while(!que.empty()){
            TreeNode* now = que.front(); que.pop();
            v.push_back(now -> val);
            if(now -> left != NULL) que.push(now -> left);
            if(now -> right != NULL) que.push(now -> right);
        }
        sort(v.begin(), v.end(), greater<int>());
        for(int i = 0; i < v.size(); i++){
            k--;
            if(k == 0) return v[i];
        }
        return 0;
    }
};

/**
 * 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 ans = 0;
    int k;
    void slove(TreeNode* root){
        if(root == NULL) return;
        slove(root -> right);
        if(--k == 0){
            ans = root -> val; return ;
        }
        slove(root -> left);
    }
    int kthLargest(TreeNode* root, int k) {
        this -> k = k;
        slove(root);
        return ans;
    }
};

4、剑指 Offer 68 - 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:
    TreeNode* ans;
    void slove(TreeNode* root, TreeNode* p, TreeNode* q){
        if(root -> val > p -> val && root -> val > q -> val)
            slove(root -> left, p, q);
        else if(root -> val < p -> val && root -> val < q -> val)
            slove(root -> right, p, q);
        else{
            ans = root; return ;
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        slove(root, p, q);
        return ans;
    }
};

/**
 * 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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(root){
            if(root -> val < p -> val && root -> val < q -> val) root = root -> right;
            else if(root -> val > p -> val && root -> val > q -> val) root = root -> left;
            else break;
        }
        return root;
    }
};

6、剑指 Offer 32 - II. 从上到下打印二叉树 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if(root == NULL) return ans;
        queue<TreeNode*> que; que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> ANS;
            while(size--){
                TreeNode* now = que.front(); que.pop();
                ANS.push_back(now -> val);
                if(now -> left) que.push(now -> left);
                if(now -> right) que.push(now -> right);
            }
            ans.push_back(ANS);
        }
        return ans;
    }
};

7、剑指 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 high(TreeNode* root){
        if(root == NULL) return 0;
        return max(high(root -> left), high(root -> right)) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL) return true;
        int l = high(root -> left);
        int r = high(root -> right);
        if(abs(l - r) > 1) return false;
        return isBalanced(root -> left) && isBalanced(root -> right);
    }
};

8、剑指 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* 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;
        bool l = slove(p -> left, q -> right);
        bool r = slove(p -> right, q -> left);
        return l && r;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return slove(root -> left, root -> right);
    }
};

---

2021/2/16完结（写不动了，本来想着今天晚上再写几题的，可是看了会C++就懒得动了，欸！等着明天再写吧）。