Construct Binary Search Tree from Preorder Traversal

Return the root node of a binary search tree that matches the given preorder traversal.

(Recall that a binary search tree is a binary tree where for every node, any descendant of node.left has a value < node.val, and any descendant of node.right has a value > node.val.  Also recall that a preorder traversal displays the value of the node first, then traverses node.left, then traverses node.right.)

It's guaranteed that for the given test cases there is always possible to find a binary search tree with the given requirements.

Example 1:

Input: [8,5,1,7,10,12]
Output: [8,5,10,1,7,null,12]

思路1：用queue的思想，current, left, right，每次安排下一个值，是左边还是右边即可，也就是用lower, upper来确定范围；

这题跟validate binary search tree很类似；也跟 Serialize and Deserialize BST 原理一模一样；O(N);

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int index = 0;
    public TreeNode bstFromPreorder(int[] preorder) {
        // current, left, right;
        if(preorder == null || preorder.length == 0) {
            return null;
        }
        return build(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }
    
    private TreeNode build(int[] preorder, int lower, int upper) {
        if(index == preorder.length) {
            return null;
        }
        int val = preorder[index];
        if(val < lower || val > upper) {
            return null;
        }
        TreeNode root = new TreeNode(val);
        index++;
        root.left = build(preorder, lower, val);
        root.right = build(preorder, val, upper);
        return root;
    }
}

思路2：preoder, current, left, right,第一个点就是root，然后分别找大于和小于它的区间即可；这个是O(N^2) 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        if(preorder == null) {
            return null;
        }
        int n = preorder.length;
        return build(preorder, 0, n - 1);
    }
    
    private TreeNode build(int[] preorder, int start, int end) {
        if(start > end) {
            return null;
        }
        if(start == end) {
            return new TreeNode(preorder[start]);
        }
        TreeNode root = new TreeNode(preorder[start]);
        int i = start + 1;
        for(; i <= end; i++) {
            if(preorder[i] > root.val) {
                break;
            }
        }
        root.left = build(preorder, start + 1, i - 1);
        root.right = build(preorder, i, end);
        return root;
    }
}