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

669. 修剪二叉搜索树

public TreeNode trimBST(TreeNode root, int low, int high) {
    List<Integer> inAns = new ArrayList<>();
    List<Integer> preAns = new ArrayList<>();
    inOrder(root, inAns);
    preOrder(root, preAns);
    List<Integer> updateInList = new ArrayList<>();
    List<Integer> updatePreList = new ArrayList<>();
    inAns.forEach(i -> {
        if (low <= i && i <= high) {
            updateInList.add(i);
        }
    });
    preAns.forEach(i -> {
        if (low <= i && i <= high) {
            updatePreList.add(i);
        }
    });
    int[] updateInNums = new int[updateInList.size()];
    int[] updatePreNums = new int[updatePreList.size()];
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < updateInList.size(); i++) {
        updateInNums[i] = updateInList.get(i);
        map.put(updateInList.get(i), i);
    }
    for (int i = 0; i < updatePreList.size(); i++) {
        updatePreNums[i] = updatePreList.get(i);
    }

    return build(updatePreNums,updateInNums, 0, updateInNums.length - 1, 0, updatePreNums.length - 1, map);
}

public void inOrder(TreeNode root, List<Integer> ans) {
    if (root == null) {
        return;
    }
    inOrder(root.left, ans);
    ans.add(root.val);
    inOrder(root.right, ans);
}

public void preOrder(TreeNode root, List<Integer> ans) {
    if (root == null) {
        return;
    }
    ans.add(root.val);
    preOrder(root.left, ans);
    preOrder(root.right, ans);
}

public TreeNode build(int[] preOrder, int[] inOrder, int inHead, int inTail, int preHead, int preTail,
                      Map<Integer, Integer> map) {
    if (inHead > inTail || preHead > preTail) {
        return null;
    }
    int rootValue = preOrder[preHead];
    int rootIndex = map.get(rootValue);
    int instance = rootIndex - inHead;
    TreeNode newRoot = new TreeNode(rootValue);
    newRoot.left = build(preOrder, inOrder, inHead, inHead + instance - 1, preHead + 1, preHead + instance, map);
    newRoot.right = build(preOrder, inOrder, inHead + instance + 1, inTail, preHead + instance + 1, preTail, map);
    return newRoot;
}

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

public TreeNode sortedArrayToBST(int[] nums) {
    return build(nums, 0, nums.length - 1);

}

public TreeNode build(int[] nums, int head, int tail) {
    if (head > tail) {
        return null;
    }
    int rootIndex = head + ((tail - head) / 2);
    int rootValue = nums[rootIndex];
    TreeNode newTreeNode = new TreeNode(rootValue);
    newTreeNode.left = build(nums, head, rootIndex - 1);
    newTreeNode.right = build(nums, rootIndex + 1, tail);

    return newTreeNode;
}

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

public TreeNode convertBST(TreeNode root) {
    List<Integer> ans = new ArrayList<>();
    inOrder(root, ans);
    int total = 0;
    for (Integer an : ans) {
        total += an;
    }
    inAndUpdateOrder(root, ans, total);
    return root;
}

public void inOrder(TreeNode root, List<Integer> list) {
    if (root == null) {
        return;
    }
    inOrder(root.left, list);
    list.add(root.val);
    inOrder(root.right, list);
}

public void inAndUpdateOrder(TreeNode root, List<Integer> list, int total) {
    if (root == null) {
        return;
    }
    int updateValue = getUpdateValue(list, root.val, total);
    root.val = updateValue;
    inAndUpdateOrder(root.left, list, total);
    inAndUpdateOrder(root.right, list, total);
}

public int getUpdateValue(List<Integer> list, int currVal, int total) {
    int sum = 0;
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i) == currVal) {
            break;
        }
        sum += list.get(i);

    }
    return total - sum;

}