# 98. Validate Binary Search Tree



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

Assume a BST is defined as follows:

* The left subtree of a node contains only nodes with keys **less than** the node's key.
* The right subtree of a node contains only nodes with keys **greater than** the node's key.
* Both the left and right subtrees must also be binary search trees.

**Example 1:**

```
Input:
    2
   / \
  1   3
Output: true
```

**Example 2:**

```
    5
   / \
  1   4
     / \
    3   6
Output: false
Explanation: The input is: [5,1,4,null,null,3,6]. The root node's value
             is 5 but its right child's value is 4.
```

Naive idea：

```python
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        traverse = []
        self.inorder(root, traverse)
        
        for i in range(1, len(traverse)): # 为保证 i - 1 不会出界，从 index = 1 开始
            if traverse[i] <= traverse[i - 1]:
                return False
        return True
        
    def inorder(self, root, traverse): # recursive 一般写到最后一个 None 节点再判断比较简洁
        if not root:
            return None
        self.inorder(root.left, traverse)
        traverse.append(root.val)
        self.inorder(root.right, traverse)
```

Iterative In-order traverse

```python
class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        pre = None
        stack = []
        while(root or stack):
            while(root):
                stack.append(root)
                root = root.left
            root = stack.pop()  # 当 root 遇到 None 时，从 stack 的 candidates 中取出上一个
            if pre and root.val <= pre.val:
                return False
            pre = root
            root = root.right
        return True
```



