D21 修剪二叉搜索树 将有序数组转换为二叉搜索树 二叉搜索树转换为累加树 + 总结

二叉树part08

669. 修剪二叉搜索树 - 力扣（LeetCode）

递归 终止条件 当root的值小于low 将右子树直接返回 同理当大于high

    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root == null) return null;
//        中序遍历 中左右
        if(root.val<low){
            TreeNode right = trimBST(root.right,low,high);
            return right;
        }
        if(root.val>high){
            TreeNode left = trimBST(root.left,low, high);
            return left;
        }
        root.left = trimBST(root.left,low,high);
        root.right = trimBST(root.right,low, high);
        return root;
    }

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

将有序数组从中间分开，二分法的创建 二叉搜索树

    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode tree = createTree(nums, 0, nums.length-1);
        return tree;
    }
//    递归的创建每一个结点的左右子树
    TreeNode createTree(int[] nums,int left, int right){
        if(left>right){
            return null;
        }
        int mid = (left+right)/2;
//        防止 整数溢出 mid =left+(right-left)/2
        TreeNode treeNode = new TreeNode(nums[mid]);
        treeNode.left = createTree(nums, left, mid - 1);
        treeNode.right =createTree(nums,mid+1,right);
        return treeNode;
    }

AI tell me:

将有序数组转换为平衡二叉搜索树的功能，但有一些地方可以优化和改进。特别是，你不需要对数组进行反转，也不需要显式地创建左右子节点后再递归构建子树。可以通过递归直接构建整个树。

将有序数组从中间分开，降序的创建 二叉搜索树

public TreeNode sortedArrayToBST(int[] nums) {
    int mid = nums.length/2;
    int[] nums1 = Arrays.copyOfRange(nums,0,mid);
    reverseArray(nums1);
    int[] nums2 = Arrays.copyOfRange(nums,mid + 1, nums.length);
    TreeNode treeNode = new TreeNode(nums[mid]);
    if(nums1.length == 0){
         treeNode.left =null;
    }else {
        treeNode.left = new TreeNode(nums1[0]);
    }
    if(nums2.length == 0){
        treeNode.right =null;
    }else {
        treeNode.right = new TreeNode(nums2[0]);
    }
    createTree(treeNode.left,nums1);
    createTree(treeNode.right,nums2);
    return treeNode;
}
void reverseArray(int[] array) {
    int n = array.length;
    for (int i = 0; i < n / 2; i++) {
        // 交换第i个元素和倒数第i+1个元素
        int temp = array[i];
        array[i] = array[n - i - 1];
        array[n - i - 1] = temp;
    }
}
void createTree(TreeNode treeNode,int[] nums){
    if(treeNode == null) return;
    for(int i=1 ;i<nums.length;i++){
        insert(treeNode,nums[i]);
    }
}
void insert(TreeNode treeNode,int value){
    if(value>treeNode.val){
        if(treeNode.right!=null){
            insert(treeNode.right,value);
        }else {
            treeNode.right = new TreeNode(value);
        }

    }else if(value<treeNode.val){
        if(treeNode.left!=null){
            insert(treeNode.left,value);
        }else {
            treeNode.left = new TreeNode(value);
        }

    }
}

538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）

递归 右中左 从最大的右下角开始累加 二叉搜索树上的双指针

int pre =0;
    public TreeNode convertBST(TreeNode root) {
//        右中左 序列遍历  同时双指针 cur pre ，其中pre记录先前结点值
        inorder(root);
        return root;
    }
    void inorder(TreeNode root){
        if(root == null) return;
        inorder(root.right);
        root.val = pre+root.val;
        pre = root.val;
        inorder(root.left);
    }

非递归 类中序 右中左 其中中序非递归只需会一种

    public TreeNode convertBST(TreeNode root) {
//        右中左
//       右不为空进栈  右为空 出栈 走左子树
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        int pre =0;
        while (cur !=null || !stack.isEmpty()){
//            右不为空进栈 走右子树
            if(cur !=null){
                stack.push(cur);
                cur = cur.right;
            }else {
//                右为空 出栈 走左子树
                cur= stack.peek();
//                出栈访问 为中
                cur.val = cur.val + pre;
                pre = cur .val;
                stack.pop();
                cur= cur.left;
            }
        }
        return root;
    }

二叉树总结：