LeetCode: Validate Binary Search Tree

Given a binary tree, determine if it is a valid binary search tree (BST).

我想到了用中序遍历，保存到一个数组中，再检查数组是否是有序的。但是我需要O(n)的额外空间保存这个数组。

网上看到一种和这个一样的方法，但是不需要额外空间，但是没太看懂。

public static boolean isValidBST(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        traverse(root, list);
        
        for (int i=0; i<list.size()-1; i++) {
            if (list.get(i) >= list.get(i+1)) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void traverse (TreeNode root, ArrayList<Integer> list) {    
        if (root != null) {
            traverse(root.left, list);
            list.add(root.val);
            traverse(root.right, list);
        }
    }

 

bool isBSTInOrderHelper(BinaryTree *p, int& prev) {
  if (!p) return true;
  if (isBSTInOrderHelper(p->left, prev)) {
    if (p->data > prev) {
      prev = p->data;
      return isBSTInOrderHelper(p->right, prev);
    } else {
      return false;
    }
  }
  else {
    return false;
  }
}

 

另外一种不需要额外空间的方法是确定每个元素的范围，然后检查这个元素是否在范围内。

递归判断，递归时传入两个参数，一个是左界，一个是右界，节点的值必须在两个界的中间，同时在判断做子树和右子树时更新左右界。

class Solution {
public:
    bool check(TreeNode *node, int leftVal, int rightVal)
    {
        if (node == NULL)
            return true;
            
        return leftVal < node->val && node->val < rightVal && check(node->left, leftVal, node->val) &&
            check(node->right, node->val, rightVal);
    }
    
    bool isValidBST(TreeNode *root) {
        return check(root, INT_MIN, INT_MAX);        
    }
};