代码随想录算法训练营第十七天（二叉树7）

文档讲解：代码随想录

视频讲解：LeetCode：669. 修剪二叉搜索树_哔哩哔哩_bilibili

状态：

LeetCode 669.修剪二叉搜索树 

// 递归
class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if(root == null)return root;
        if(root.val > high)return trimBST(root.left, low, high);
        if(root.val < low)return trimBST(root.right, low, high);
        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 root;
        while(root != null && !(root.val >= low && root.val <= high)) {
            if(root.val > high)root = root.left;
            else if(root.val < low)root = root.right;
        }
        TreeNode cur = root;
        while(cur!= null) {
            while(cur.left != null && cur.left.val < low)cur.left = cur.left.right;
            cur = cur.left;
        }
        cur = root;
        while(cur != null) {
            while(cur.right != null && cur.right.val > high)cur.right = cur.right.left;
            cur = cur.right;
        }
        return root;
    }
}

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

// 递归
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return build(nums, 0, nums.length - 1);
    }
    public TreeNode build(int[] nums, int left, int right) {
        if(left > right)return null;
        int mid = left + ((right - left) / 2);
        TreeNode root = new TreeNode(nums[mid]);
        root.left = build(nums, left, mid - 1);
        root.right = build(nums, mid + 1, right);
        return root;
    }
}

// 迭代
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums.length == 0)return null;
        ArrayDeque<TreeNode> nodeDeque = new ArrayDeque<>();
        ArrayDeque<Integer> leftDeque = new ArrayDeque<>();
        ArrayDeque<Integer> rightDeque = new ArrayDeque<>();
        TreeNode root = new TreeNode(0);
        nodeDeque.push(root);
        leftDeque.push(0);
        rightDeque.push(nums.length - 1);
        while(!nodeDeque.isEmpty()) {
            TreeNode cur = nodeDeque.pop();
            int left = leftDeque.pop();
            int right = rightDeque.pop();
            int mid = left + ((right - left) / 2);
            cur.val = nums[mid];
            if(left < mid) {
                leftDeque.push(left);
                rightDeque.push(mid - 1);
                TreeNode leftNode = new TreeNode(0);
                cur.left = leftNode;
                nodeDeque.push(leftNode);
            }
            if(right > mid) {
                leftDeque.push(mid + 1);
                rightDeque.push(right);
                TreeNode rightNode = new TreeNode(0);
                cur.right = rightNode;
                nodeDeque.push(rightNode);
            }
        }
        return root;
    }
}

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

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

// 迭代
class Solution {
    public TreeNode convertBST(TreeNode root) {
        if(root == null)return root;
        Stack<TreeNode> deque = new Stack<>();
        TreeNode cur = root;
        int sum = 0;
        while(cur != null || !deque.isEmpty()) {
            if(cur != null) {
                deque.push(cur);
                cur = cur.right;
            }
            else {
                cur = deque.pop();
                sum += cur.val;
                cur.val = sum;
                cur = cur.left;
            }
        }
        return root;
    }
}

心得：二叉树终于做完了