LeetCode 1008. Construct Binary Search Tree from Preorder Traversal

原题链接在这里：https://leetcode.com/problems/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.)

Example 1:

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

 

Note: 

1. 1 <= preorder.length <= 100
2. The values of preorder are distinct.

题解：

The first element should be root. As BST, root left subtree should be smaller than root value, right subtree should be bigger than root value.

Could use root value as pivot and find out array corresponding to left subtree, also array corresponding to right subtree.

Time Complexity: O(nlogn). Each level of tree, it takes O(n) time, tree height should be O(logn).

Space: O(logn).

AC Java: 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        if(preorder == null || preorder.length == 0){
            return null;
        }
        
        return dfs(preorder, 0, preorder.length-1);
    }
    
    private TreeNode dfs(int[] preorder, int l, int r){
        if(l > r){
            return null;
        }
        
        TreeNode root = new TreeNode(preorder[l]);
        int biggerIndex = l+1;
        while(biggerIndex<=r && preorder[biggerIndex]<preorder[l]){
            biggerIndex++;
        }
        
        root.left = dfs(preorder, l+1, biggerIndex-1);
        root.right = dfs(preorder, biggerIndex, r);
        return root;
    }
}

For each node, it should be lower and higher bound.

For current value, if it is not within the bound, return null. 

Otherwise, use this value to construct a node and return it. Move the index.

Time Complexity: O(n). 

Space: O(logn). Regardless res.

AC Java: 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int i = 0;
    
    public TreeNode bstFromPreorder(int[] preorder) {
        if(preorder == null || preorder.length == 0){
            return null;
        }
        
        return dfs(preorder, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }
    
    private TreeNode dfs(int [] preorder, int min, int max){
        if(i>=preorder.length){
            return null;
        }
        
        if(preorder[i]<min || preorder[i]>max){
            return null;
        }
        
        TreeNode root = new TreeNode(preorder[i]);
        i++;
        root.left = dfs(preorder, min, root.val);
        root.right = dfs(preorder, root.val, max);
        return root;
    }
}

Iteration method. Use stack to store TreeNode.

When encountering new value, first peek the top of stack, assign it to top. Then while stack top is smaller than new value, keep popping and update top.

If actually it doesn't pop, then new value node is top left child. Otherwise, new value node is last popped node's right child.

Time Complexity: O(n).

Space: O(logn). Stack space, regardless res.

AC Java:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        if(preorder == null || preorder.length == 0){
            return null;
        }
        
        TreeNode root = new TreeNode(preorder[0]);
        Stack<TreeNode> stk = new Stack<TreeNode>();
        stk.push(root);
        for(int i = 1; i<preorder.length; i++){
            TreeNode cur = new TreeNode(preorder[i]);
            TreeNode top = stk.peek();
            
            while(!stk.isEmpty() && stk.peek().val<preorder[i]){
                top = stk.pop();
            }
            
            if(top.val < preorder[i]){
                top.right = cur;
            }else{
                top.left = cur;
            }
            
            stk.push(cur);
        }
        
        return root;
    }
}