代码随想录算法训练营第二三天 | 修剪二叉搜索树、将有序数组转换为二叉搜索树、把二叉搜索树转换为累加树

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

修剪二叉搜索树

修剪二叉搜索树，使得所有节点的值在[low, high]中。

注意： 当遇到不在这个区间的内的节点不能直接置 null ， 因为可能遇到其左右节点是在这个区间内的。

在上图中我们发现节点0并不符合区间要求，那么将节点0的右孩子 节点2 直接赋给 节点3的左孩子就可以了（就是把节点0从二叉树中移除），如图：

class Solution {
    TreeNode right;
    TreeNode left;
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) return null;
        if (root.val < low) {
            right = trimBST(root.right, low, high); // 继续向右遍历，不能不递归直接return 
            return right;
        }
        if (root.val > high) {
            left = trimBST(root.left, low, high);
            return left;
        }
        root.left = trimBST(root.left, low, high);   // root->left接入符合条件的左孩子
        root.right = trimBST(root.right, low, high);  // root->right接入符合条件的右孩子
        return root;
    }
}

迭代法

因为二叉搜索树的有序性，不需要使用栈模拟递归的过程。

在剪枝的时候，可以分为三步：

1. 将root移动到[L, R] 范围内，注意是左闭右闭区间
2. 剪枝左子树
3. 剪枝右子树

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) return null;
        // 根节点处理逻辑
        // 处理头结点，让root移动到[L, R] 范围内，注意是左闭右闭
        while (root != null && (root.val < low || root.val > high)) {
            if (root.val < low) {
                root = root.right;
            } else {
                root = root.left;
            }
        }
        TreeNode cur = root;

        // 左子树处理逻辑
        while (cur != null) {
            while (cur.left != null && cur.left.val < low) {
                cur.left = cur.left.right;
            }
            cur = cur.left;
        }

        cur = root;  //go back to root;

        // 右子树处理逻辑
        while (cur != null) {
            while (cur.right != null && cur.right.val > high) {
                cur.right = cur.right.left;
            }
            cur = cur.right;
        }

        return root;
    }
}

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

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

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

这个题让构造平衡二叉搜索树，怎么样是平衡的呢，第一步想的就是取中间节点作为根节点，左右分隔，这样左右节点数就一致了，但是向下递归时，仍旧需要保持这一策略，这样每个节点的左右两个子树的高度差的绝对值将会不超过 1。

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

    private TreeNode traversal(int[] nums, int left, int right) {
        // 当区间 left > right的时候，就是空节点
        // 平衡二叉树： 每次递归都选中间节点，左右分隔，这样左右节点数就一致了/差1。
        if (left > right) return null;
        int mid = left + (right - left) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = traversal(nums, left, mid - 1);
        root.right = traversal(nums, mid + 1, right);
        return root;
    }
}

迭代法可以通过三个队列来模拟，一个队列放遍历的节点，一个队列放左区间下标，一个队列放右区间下标。

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if (nums.length == 0) return null;

        // 根节点初始化
        TreeNode root = new TreeNode(-1);
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        Queue<Integer> leftQueue = new LinkedList<>();
        Queue<Integer> rightQueue = new LinkedList<>();

        // 根节点入队列
        nodeQueue.offer(root);
        // 0 为左区间下标初始位置
        leftQueue.offer(0);
		// nums.length - 1为右区间下标初始位置
		rightQueue.offer(nums.length - 1);

        while (!nodeQueue.isEmpty()) {
            TreeNode currNode = nodeQueue.poll();
            int left = leftQueue.poll();
            int right = rightQueue.poll();
            int mid = left + ((right - left) / 2);
            
            // 将mid对应的元素给中间节点
			currNode.val = nums[mid];

			// 处理左区间
			if (left <= mid - 1) {
				currNode.left = new TreeNode(-1);
				nodeQueue.offer(currNode.left);
				leftQueue.offer(left);
				rightQueue.offer(mid - 1);
			}

			// 处理右区间
			if (right >= mid + 1) {
				currNode.right = new TreeNode(-1);
				nodeQueue.offer(currNode.right);
				leftQueue.offer(mid + 1);
				rightQueue.offer(right);
			}
		}
		return root;
    }
}

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

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

右中左遍历，记录前一个节点的数值，加在当前节点的数值上。

class Solution {
    int pre = 0; // 前一个节点的数值
    public TreeNode convertBST(TreeNode root) {
        pre = 0;
        traversal(root);
        return root;
    }

    private void traversal(TreeNode cur) {
        if (cur == null) return;
        traversal(cur.right);
        cur.val += pre;
        pre = cur.val;
        traversal(cur.left);
    }
}