树第2天

第2天

654. 最大二叉树

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return build(nums, 0, nums.length - 1);
    }

    TreeNode build(int[] nums,int left,int right){
        if(left > right) return null;
        int maxIndex = left;
        for(int i = left; i <= right; i++){
            if(nums[i] > nums[maxIndex]) maxIndex = i;
        }

        TreeNode res = new TreeNode(nums[maxIndex]);

        res.left = build(nums, left, maxIndex - 1);
        res.right = build(nums, maxIndex + 1, right);
        
        return res;
    }
}

105. 从前序与中序遍历序列构造二叉树

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return find(preorder, inorder, 0, 0, inorder.length - 1);
    }

    TreeNode find(int[] preorder, int[] inorder, int preIndex, int inStart, int inEnd){
        if(inStart > inEnd) return null;
        TreeNode res = new TreeNode(preorder[preIndex]);

        int middle = 0;
        for(int i = inStart; i <= inEnd; i++){
            if(inorder[i] == preorder[preIndex]){
                middle = i;
                break;
            }
        }
        res.left = find(preorder, inorder, preIndex + 1, inStart, middle - 1);
        res.right = find(preorder, inorder, preIndex + middle - inStart + 1, middle + 1, inEnd);

        return res;
    }
}

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, inorder, Integer.MAX_VALUE + 1L);
    }

    int pre = 0, in = 0;

    TreeNode build(int[] preorder, int[] inorder, long stop){
        if(pre == preorder.length)
            return null;
        if(stop == inorder[in]){
            in++;
            return null;
        }

        TreeNode res = new TreeNode(preorder[pre++]);
        res.left = build(preorder, inorder, res.val);
        res.right = build(preorder, inorder, stop);

        return res;
    }
}

106. 从中序与后序遍历序列构造二叉树

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        in = inorder.length - 1; post = postorder.length - 1;
        return build(inorder, postorder, Integer.MAX_VALUE);
    }

    int in, post;

    TreeNode build(int[] inorder, int[] postorder, long stop){
        if(post < 0)
            return null;
        if(stop == inorder[in]){
            in--;
            return null;
        }

        TreeNode res = new TreeNode(postorder[post--]);
        res.right = build(inorder, postorder, res.val);
        res.left = build(inorder, postorder, stop);

        return res;
    }
}