【五月集训】（第二十天）—— 二叉搜索树

---

解题报告

二叉搜索树中的搜索

题目链接：700. 二叉搜索树中的搜索

解题思路

类似于二分查找，从根节点开始，目标值小于根节点值就找左子树，大于就找右子树，直到遇到相等的节点。

解题代码

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root == nullptr){
            return nullptr;
        }
        if(val < root -> val){
            return searchBST(root -> left, val);
        }else if(val > root -> val){
            return searchBST(root -> right, val);
        }
        return root;
    }
};

二叉搜索树中第K小的元素

题目链接：230. 二叉搜索树中第K小的元素

解题思路

二叉搜索树按照中序遍历一定有序的，按照中序遍历的顺序找到第k个数。

解题代码

class Solution {
public:
    int ans = -1;
    void dfs(TreeNode* root, int& k){
        if(root){
            dfs(root -> left, k);
            if(--k == 0){
                ans = root -> val;
            }
            dfs(root -> right, k);
        }
    }
    int kthSmallest(TreeNode* root, int k) {
        dfs(root, k);
        return ans;
    }
};

将有序数组转换为二叉搜索树

题目链接：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]);
        n -> left = dfs(nums, l, mid - 1);
        n -> right = dfs(nums, mid + 1, r);
        return n;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        return dfs(nums, l, r);
    }
};

将二叉搜索树变平衡

题目链接：1382. 将二叉搜索树变平衡

解题思路

先中序遍历二叉树，得到一个有序的数组，再将这个有序数组转为平衡树（与上一题一样的方法）。

解题代码

class Solution {
public:
    vector<TreeNode*> ret;
    TreeNode* dfs(vector<TreeNode*> ret, int l, int r){
        if(l > r){
            return nullptr;
        }
        int mid = (l + r) >> 1;
        TreeNode* n = ret[mid];
        n -> left = dfs(ret, l, mid - 1);
        n -> right = dfs(ret, mid + 1, r);
        return n;
    }

    void inorder(TreeNode* root){
        if(root){
            inorder(root -> left);
            ret.push_back(root);
            inorder(root -> right);
        }
    }

    TreeNode* balanceBST(TreeNode* root) {
        inorder(root);
        int l = 0, r = ret.size() - 1;
        return dfs(ret, l, r);
    }
};