【Leetcode】1008. Construct Binary Search Tree from Preorder Traversal

题目地址：

https://leetcode.com/problems/construct-binary-search-tree-from-preorder-traversal/

给定一个二叉搜索树的先序遍历数组$A$，要求返回该树树根。

法1：DFS。用一个指针指向$A$当前要处理的数的下标。在递归的每一层的时候，考虑一下指针指向位置的数是否满足范围的条件，如果满足，就new出来，将其作为根节点，右移指针，然后递归进入下一层，先建立左子树，再建立右子树，同时要把左子树右子树的范围作为参数传递下去。当指针指向了$A$末尾的时候是递归结束条件。代码如下：

public class Solution {
    
    // 记录当前走到哪个下标了
    private int idx;
    
    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 (idx == preorder.length) {
            return null;
        }
    
        int val = preorder[idx];
        if (min < val && val < max) {
            TreeNode root = new TreeNode(val);
            idx++;
            
            root.left = dfs(preorder, min, val);
            root.right = dfs(preorder, val, max);
            return root;
        }
        
        return null;
    }
}

class TreeNode {
    int val;
    TreeNode left, right;
    
    public TreeNode(int val) {
        this.val = val;
    }
}

时间复杂度$O(n)$，空间$O(h)$，这里$h$指的是最后建出来的树的树高。

法2：栈。如果数组空直接返回空树。接着由于是先序遍历，树根已经知道了，所以先把树根new出来，接着从$A[1]$开始遍历数组，如果遇到比栈顶小的数，则new出节点，连到栈顶左指针上，然后将其入栈；如果遇到比栈顶大的数，则先将栈顶不停出栈，并存下最后一个小于新来的数的节点$c$，接着new出节点，将其连到$c$的右指针上。最后返回树根即可。代码如下：

import java.util.Deque;
import java.util.LinkedList;

public class Solution {
    public TreeNode bstFromPreorder(int[] preorder) {
        if (preorder == null || preorder.length == 0) {
            return null;
        }
        
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode root = new TreeNode(preorder[0]);
        stack.push(root);
        
        for (int i = 1; i < preorder.length; i++) {
            if (preorder[i] < stack.peek().val) {
                stack.peek().left = new TreeNode(preorder[i]);
                stack.push(stack.peek().left);
            } else {
            	// cur记录最后出栈的且比preorder[i]小的节点
                TreeNode cur = null;
                while (!stack.isEmpty() && stack.peek().val < preorder[i]) {
                    cur = stack.pop();
                }
                
                cur.right = new TreeNode(preorder[i]);
                stack.push(cur.right);
            }
        }
        
        return root;
    }
}

时空复杂度一样。