《五月集训》（第二十天）——平衡二叉树

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是五月集训第二十天：平衡二叉树🔥🔥🔥

一、练习题目

        700. 二叉搜索树中的搜索
        230. 二叉搜索树中第K小的元素
        108. 将有序数组转换为二叉搜索树
        1382. 将二叉搜索树变平衡

二、算法思路

• 1、700. 二叉搜索树中的搜索：利用BST的特性类似二分查找，如果val < root->val递归去找左子树，val > root->val递归去找右子树。
• 2、230. 二叉搜索树中第K小的元素：利用BST中序遍历后是一个有序递增的特性，不断减少k，如果k减到0了就说明找到了。值得注意的是，如果使用函数传参k的时候需要注意值传递和引用传递，或者定义一个全局变量。
• 3、108. 将有序数组转换为二叉搜索树：找数组的中点，它的左边构成左子树，右边构成右子树。
• 4、1382. 将二叉搜索树变平衡：先中序遍历二叉搜索树返回有序数组，再利用第三题的函数接口，因为第三题是一个左子树一个右子树去生成，肯定是保证平衡的。

三、源码剖析

// 700. 二叉搜索树中的搜索
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == nullptr)
            return root;
        if(val < root->val)
            return searchBST(root->left, val);
        else if(val > root->val)
            return searchBST(root->right, val);
        return root;
    }
};

• 1、类似二分的作法。

// 230. 二叉搜索树中第K小的元素
class Solution {
    int ans = -1;
public:
    void dfs(TreeNode* root, int &k) { //(1)
        if(root == nullptr)
            return;
        dfs(root->left, k);
        if( --k == 0){
            ans = root->val; //(2)
        }
        dfs(root->right, k);
   }
    int kthSmallest(TreeNode* root, int k) {
        dfs(root, k);
        return ans;
   }
};

• 1、函数传参的话要用引用传递，不然的话值传递只是拷贝，不会对k本身有影响，会错；
• 2、k变到0说明我们找到了。

// 108. 将有序数组转换为二叉搜索树
class Solution {
public:
    TreeNode* dfs(vector<int>& nums, int l, int r) {
        if(l > r)
            return nullptr;
        int mid = (l + r) >> 1;
        TreeNode* n = new TreeNode(nums[mid]); //(1)
        n->left = dfs(nums, l, mid-1); //(2)
        n->right = dfs(nums, mid+1, r); //(3)
        return n;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        return dfs(nums, l, r);
    }
};

• 1、找中点作为根结点；
• 2、根节点左边去递归构成左子树；
• 3、根节点右边去递归构成右子树。

// 1382. 将二叉搜索树变平衡
class Solution {
    vector<TreeNode*> ret;
public:
    TreeNode* dfs(vector<TreeNode*>& nums, int l, int r) {
    if(l > r)
        return nullptr;
    int mid = (l + r) >> 1;
    TreeNode* n = nums[mid];
    n->left = dfs(nums, l, mid-1);
    n->right = dfs(nums, mid+1, r);
    return n;
}
    TreeNode* sortedArrayToBST(vector<TreeNode*>& nums) {
        int l = 0, r = nums.size() - 1;
        return dfs(nums, l, r);
}
    void inorder(TreeNode* root) { //(1)
        if(root) {
            inorder(root->left);
            ret.push_back(root);
            inorder(root->right);
       }
}
    TreeNode* balanceBST(TreeNode* root) {
        ret.clear();
        inorder(root);
        return sortedArrayToBST(ret); //(2)
}
};

• 1、中序遍历形成一个升序数组；
• 2、利用第三题的接口即可。