day23 二叉树part9(669. 修剪二叉搜索树108. 将有序数组转换为二叉搜索树538. 把二叉搜索树转换为累加树)

669. 修剪二叉搜索树

中等
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。
所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        return traversal(root, low, high);
        
    }
    public TreeNode traversal(TreeNode root, int low, int high) {
        if (root == null) return null;
        // root.val 小于low，但是在root右子树大于root.val，所以右子树中可能还存在满足条件的
        if (root.val < low) {
            return traversal(root.right, low, high); // 返回右子树查找结果，直接丢弃左子树
        }
        // root.val 大于low，但是在root左子树小于root.val，所以左子树中可能还存在满足条件的
        if (root.val > high) {
            return traversal(root.left, low, high); // 返回左子树查找结果，直接丢弃右子树
        }
        // 剩下的就是在[low, high] 区间的了,但是它的左右子树不能保证还满足要求，继续递归
        root.left = traversal(root.left, low, high);
        root.right = traversal(root.right, low, high);

        return root;
    }
}

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

简单
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

// 独立做出来了，代码也比较简洁
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        int numsLen = nums.length;
        if (numsLen == 0) return null;
        return preOrder(nums, 0, numsLen - 1); // 这里是numsLen - 1，不是numsLen
    }
    public TreeNode preOrder(int[] nums, int left, int right){
        if (left > right) return null;
        int mid = left + (right - left) / 2;
        TreeNode newNode = new TreeNode(nums[mid]);
        newNode.left = preOrder(nums, left, mid - 1);
        newNode.right = preOrder(nums, mid + 1, right);
        
        return newNode;
    }
}

538. 把二叉搜索树转换为累加树

已解答
中等
给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。
提醒一下，二叉搜索树满足下列约束条件：
节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树

// 我写的笨办法，利用了BST中序遍历是有序数组理论的基础, 其实累加那里如果从后往前加的话也会快很多
class Solution {
    List<Integer> treeNums = new ArrayList<>();
    int index = 0;
    public TreeNode convertBST(TreeNode root) {
        inOrder(root);
        inOrderChange(root);
        return root;
    }

    // 中序遍历并记录
    public void inOrder(TreeNode node) {
        if (node == null) return;
        inOrder(node.left);
        treeNums.add(node.val);
        inOrder(node.right);
    }
    // 中序遍历并改变
    public void inOrderChange(TreeNode node) {
        if (node == null) return;
        inOrderChange(node.left);
        node.val = getChangeNum(index);
        index++;
        inOrderChange(node.right);
    }
    public int getChangeNum(int n) {
        int sum = 0;
        for (int i = n; i < treeNums.size(); i++) {
            sum += treeNums.get(i);
        }
        return sum;
    }
}

// 正确做法
class Solution {
    TreeNode pre = null;
    public TreeNode convertBST(TreeNode root) {
        convertInOrder(root);
        return root;
    }
    public void convertInOrder(TreeNode node) {
        if (node == null) return;
        convertInOrder(node.right);
        if (pre != null) { //只要不是最右边那个节点
            node.val += pre.val;
        }
        pre = node;
        convertInOrder(node.left);
    }
}