代码随想录Day25

669.修剪二叉搜索树

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

思路：跟删除二叉树的指定节点有点像，肯定都是要遇到目标值范围以外的节点后，需要深入进入节点里面处理

尝试（部分AC）

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root == null) return null;
        if(root.val < low ){
            if(root.right == null) return null;
            return root.right;
        }
        if(root.val > high ){
            if(root.left == null) return null;
            return root.left;
        }
        if(root.val <= high && root.val >= low ){
            return root;
        }
        root.left = trimBST(root.left,low,high);
        root.right = trimBST(root.right,low,high);
        return root;
    }
}

答案

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) {
            return null;
        }
        if (root.val < low) {
            return trimBST(root.right, low, high);
        }
        if (root.val > high) {
            return trimBST(root.left, low, high);
        }
        // root在[low,high]范围内
        root.left = trimBST(root.left, low, high);
        root.right = trimBST(root.right, low, high);
        return root;
    }
}

小结

🍉思路有点接近答案了，关键是，当前节点小了，就要往节点的右孩子递归；当前节点大了，就要往节点的左孩子递归。

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

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

思路：双指针，先找到根节点，再递归，由中心向两边扩展，不断把节点补充到树里面

递归

1、单层递归逻辑：把

尝试

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        int leftIndex = 0;
        int rightIndex = nums.length - 1;
        while(rightIndex - leftIndex > 1){
            rightIndex --;
            leftIndex ++;
        }
        return addNode(nums,leftIndex,rightIndex);
    }
    public TreeNode addNode(int[] nums,int leftIndex,int rightIndex){
        TreeNode root = new TreeNode(nums[leftIndex]);
        
        root.right = addNode(nums,leftIndex,rightIndex);
        root.left = addNode(nums,leftIndex,rightIndex);
    }
}

答案

class Solution {
	public TreeNode sortedArrayToBST(int[] nums) {
		TreeNode root = traversal(nums, 0, nums.length - 1);
		return root;
	}

	// 左闭右闭区间[left, right]
	private TreeNode traversal(int[] nums, int left, int right) {
		if (left > right) return null;

		int mid = left + ((right - left) >> 1);
		TreeNode root = new TreeNode(nums[mid]);
		root.left = traversal(nums, left, mid - 1);
		root.right = traversal(nums, mid + 1, right);
		return root;
	}
}

小结

🍉关键是单层递归逻辑，根据传入的左右指针，找到中间的数字，这个数字就是根节点

🍉递归函数，怎么处理根节点，就怎么处理其它节点，根节点一开始要找到数组的中间位置，其它节点的填充也如此

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

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

思路：先中序遍历，得到有序数组，再把有序数组转变为累加树

尝试

class Solution {
    public static List<Integer> temp = new ArrayList<Integer>();
    public TreeNode convertBST(TreeNode root) {
        midOrder(root);
        int[] nums = temp.stream().mapToInt(Integer::intValue).toArray();
        TreeNode result = traversal(nums, 0, nums.length - 1);
		return result;

    }
    public List<Integer> midOrder(TreeNode root){
        if(root == null) return null;
        midOrder(root.left);
        temp.add(root.val);
        midOrder(root.right);
        return temp;
    }
    // 左闭右闭区间[left, right]
	private TreeNode traversal(int[] nums, int left, int right) {
		if (left > right) return null;

		int mid = left + ((right - left) >> 1);
		TreeNode root = new TreeNode(nums[mid]);
		root.right = traversal(nums, left, mid - 1);
		root.left = traversal(nums, mid + 1, right);
		return root;
	}
}

答案

class Solution {
    int sum;
    public TreeNode convertBST(TreeNode root) {
        sum = 0;
        convertBST1(root);
        return root;
    }

    // 按右中左顺序遍历，累加即可
    public void convertBST1(TreeNode root) {
        if (root == null) {
            return;
        }
        convertBST1(root.right);
        sum += root.val;
        root.val = sum;
        convertBST1(root.left);
    }
}

小结

🍉思维被定住了，以为一定要左右中，直接右左中遍历，挨个更新二叉树的数值就行