LeetCode 255. Verify Preorder Sequence in Binary Search Tree - 二叉搜索树（Binary Search Tree）系列题5

Given an array of unique integers preorder, return true if it is the correct preorder traversal sequence of a binary search tree.

Example 1:

Input: preorder = [5,2,1,3,6]
Output: true

Example 2:

Input: preorder = [5,2,6,1,3]
Output: false

Constraints:

• 1 <= preorder.length <= 104
• 1 <= preorder[i] <= 104
• All the elements of preorder are unique.

Follow up: Could you do it using only constant space complexity?

 题目大意是给定一个数组，问数组中各数值的顺序是否是一棵二叉搜索树的前序遍历的顺序。其实这题还可以换种问法，给定一棵二叉树的前序遍历的数组，验证其是否为一棵有效的二叉搜索树。

换个问法后就很容易看出这题跟98. Validate Binary Search Tree很像，不同的是这题需要从数组中找到根节点，左子树和右子树。根据前序遍历的特点，根节点就是第一个数，然后找到第一个大于根节点值的数的位置，前半部就是左子树，右半部就是右子树。 按照98. Validate Binary Search Tree的思路，从根节点开始每个节点维护一个范围，随着递归调用一直往下传递，只有所有数都落在指定范围内才是一棵有效二叉搜索树。

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        def helper(left, right, low, high):
            if left > right:
                return True
            rootVal = preorder[left]
            if rootVal < low or rootVal > high:
                return False
            
            i = left + 1
            while i <= right:
                if preorder[i] > rootVal:
                    break
                i += 1
            
            return helper(left + 1, i - 1, low, rootVal) and helper(i, right, rootVal, high)
        
        return helper(0, len(preorder) - 1, -sys.maxsize, sys.maxsize)
        

以上解法比较直观容易想到，但是有个缺点就是每次递归调用都要查找左右子树在数组中的分割位置，耗费很多时间，容易超时。

这题有一个巧妙的解法是使用一个单调递减堆栈。遍历数组，从数组第一个数开始只要是递减的就压入堆栈中，说明每个数都落在之前所有节点的左子树中，当碰到第一个比堆栈顶部大的数，说明当前这个数是堆栈中某一个节点的右子节点，也就是说要查找当前数的直系父节点，堆栈中所有小于当前数的最大那个数就是直系父节点，由于堆栈的单调递减的，挨个弹出最后一个小于当前数的数就要找的直系父节点。由于当前数是直系父节点的右子节点，那么从当前数开始数组剩余的所有数都必须大于当前数的直系父节点的值，否则就无效，因此在遍历过程需要维护一个最小值用于判断数组剩余数是否有效。只要一碰到要找直系父节点的情况，就更新一下该最小值。用以上规则遍历整个数组，如果最后能走到最后，那说明该数组是一棵有效的二叉搜索树。

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        low = -sys.maxsize
        stack = []
        
        for v in preorder:
            if v < low:
                return False
            
            while stack and v > stack[-1]:
                low = stack.pop()
                
            stack.append(v)
            
        return True

题目还继续问空间复杂度能不能是O(1)？说明还可以继续优化，也就是不能用堆栈了。我们知道在python中数组和堆栈其实用的都是list。另外还知道，当遍历数组处理到第i个数时，堆栈里最多不会超过i个数，因此可以把数组前面已处理部分的空间来模拟一个堆栈。

class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        low = -sys.maxsize
        i = -1
        
        for v in preorder:
            if v < low:
                return False
            
            while i >= 0 and v > preorder[i]:
                low = preorder[i]
                i -= 1
                
            i += 1
            preorder[i] = v
            
        return True