代码随想录35期Day23-Java

Day23题目

LeetCode669.修剪二叉搜索树：保留二叉搜索树一个范围内的节点

核心思想：一个节点在范围内，它的子节点不一定在范围内，所以搜索到范围内的节点的时候也要同时构建它的子节点

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        // 核心思想是，如果不在范围内就直接继续找在范围内的，在范围内出现的第一个节点，直接把这个节点的左右子树全部都搞好，然后返回。
        if(root == null) return null;
        if(root.val  > high){
            return trimBST(root.left,low,high);
        }
        if(root.val < low){
            return trimBST(root.right,low,high);
        }
        // 这里就是root在范围内了
        // 构建root子树
        root.left = trimBST(root.left,low,high);
        root.right = trimBST(root.right,low,high);
        return root;
    }
}

LeetCode108.有序数组构建为二叉搜索树

核心思想：尽量构建平衡一点，不然从第一个一直向右节点插入成一个列表也行，也叫搜索树。所以使用类似分治的方法，以中间元素为分界，构建左右子树，注意数组边界

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return help(nums,0,nums.length);
    }
    public TreeNode help(int[] nums,int begin,int end){
    	// 数组左闭右开
        if(begin >= end) return null;
        // 终止条件就是这个
        if(end-begin == 1) return new TreeNode(nums[begin]);
        int mid = (end+begin)/2;
        TreeNode root = new TreeNode(nums[mid]);
        // 递归构建左右子树
        root.left = help(nums,begin,mid);
        root.right = help(nums,mid+1,end);
        return root;
    } 
}

LeetCode538.把二叉搜索树转化为累加树：从右下角开始加，每一个元素变成它比它大的节点之和

核心思想：使用右中左的遍历就ok了

class Solution {
    public TreeNode convertBST(TreeNode root) {
        // 右中左遍历即可，迭代
        int cur = 0;
        Stack<TreeNode> stack = new Stack<>();
        if(root == null) return root;
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(node != null){
                if(node.left != null){
                    stack.push(node.left);
                }
                stack.push(node);
                stack.push(null);
                if(node.right != null){
                    stack.push(node.right);
                }
            }else{
                node = stack.pop();
                cur =  cur + node.val;
                node.val = cur;
            }
        }
        return root;
    }
}

// 递归
class Solution {
    int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        help(root);
        return root;
    }
    public void help(TreeNode root){
        // 右中左
        if(root == null) return;
        help(root.right);
        sum = sum + root.val;
        root.val = sum;
        help(root.left);  
    }
}