代码随想录算法训练营第21天| LeetCode669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树

目录

题目链接：669. 修剪二叉搜索树 - 力扣（LeetCode）

题目链接：108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）

题目链接：538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）

---

    "you only need the light when it's burning low; only miss the sun when it starts to snow; only know you love her when you let her go."  

题目链接：669. 修剪二叉搜索树 - 力扣（LeetCode）

修剪二叉搜索树以确保所有节点的值在给定的范围 [low, high] 内，并保持原有的父子关系.

使用递归方法：递归处理每个节点时，需要根据当前节点的值与 low 和 high 的比较结果，决定如何处理该节点及其子节点。

具体步骤如下：

1. 如果当前节点为空，返回 null。
2. 如果当前节点的值小于 low，则当前节点及其左子树都需要被修剪，直接返回修剪后的右子树。
3. 如果当前节点的值大于 high，则当前节点及其右子树都需要被修剪，直接返回修剪后的左子树。
4. 如果当前节点的值在 [low, high] 范围内，则递归地修剪其左子树和右子树。

class Solution669 {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) {
            return null;
        }
 
        // 如果当前节点的值小于low，则修剪后的树应该在右子树中
        if (root.val < low) {
            return trimBST(root.right, low, high);
        }
 
        // 如果当前节点的值大于high，则修剪后的树应该在左子树中
        if (root.val > high) {
            return trimBST(root.left, low, high);
        }
 
        // 当前节点的值在[low, high]范围内，递归修剪左右子树
        root.left = trimBST(root.left, low, high);
        root.right = trimBST(root.right, low, high);
 
        return root; // 返回修剪后的根节点
    }
}

题目链接：108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）

将一个升序排列的整数数组转换为一棵平衡二叉搜索树（BST）。

选择数组的中间元素作为根节点，然后递归地对左右子数组进行相同的操作，确保树的平衡性。

算法步骤：

1. 找到数组的中间元素，将其作为当前子树的根节点。
2. 递归地对左半部分数组创建左子树。
3. 递归地对右半部分数组创建右子树。
4. 返回当前子树的根节点。

class Solution108 {
    public TreeNode sortedArrayToBST(int[] nums) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        return convertToBST(nums, 0, nums.length - 1);
    }
 
    // 递归方法，构建BST
    private TreeNode convertToBST(int[] nums, int left, int right) {
        if (left > right) {
            return null; // 如果左索引大于右索引，返回null
        }
 
        int mid = left + (right - left) / 2; // 计算中间索引
        TreeNode root = new TreeNode(nums[mid]); // 创建根节点
 
        root.left = convertToBST(nums, left, mid - 1); // 递归构建左子树
        root.right = convertToBST(nums, mid + 1, right); // 递归构建右子树
 
        return root; // 返回根节点
    }
}

题目链接：538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）

要将一个二叉搜索树（BST）转换为累加树（Greater Sum Tree），我们可以利用BST的性质：

二叉搜索树的中序遍历结果是按升序排序的。

而对于累加树，每个节点的新值等于原始树中所有大于或等于该节点值的节点值之和。要实现这一点，可以进行一次逆中序遍历（即先右子树、再根、后左子树的顺序），并累计已遍历节点的值总和。

算法步骤：

1. 使用一个累加变量 sum，初始化为 0，用于存储遍历过程中所有节点值的累积和。
2. 执行逆中序遍历（先访问右子节点，再访问当前节点，最后访问左子节点）。
3. 在遍历每个节点时，将累加变量 sum 更新为包括当前节点值的总和，并将当前节点的值更新为新的 sum 值。
4. 返回修改后的根节点。

class Solution538 {
    private int sum = 0;  // 初始化累加变量
    public TreeNode convertBST(TreeNode root) {
        // 反向中序遍历树
        traverse(root);
        return root;
    }
 
    // 反向中序遍历方法
    private void traverse(TreeNode node) {
        if (node == null) {
            return;
        }
 
        // 递归遍历右子树
        traverse(node.right);
 
        // 更新节点值
        sum += node.val;
        node.val = sum;
 
        // 递归遍历左子树
        traverse(node.left);
    }
}