leetcode 98： 验证二叉搜索树

题目描述： 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。
思路1：
利用二叉搜索树的性质：（！！！二叉搜索树的很多问题都是靠这个性质解决）
中序遍历的结果是有序的。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        result = []
        if not root:
            return True
        self.inorder(root, result)
        for i in range(len(result) - 1):
            if result[i] >= result[i + 1]:
                return False
        return True

    def inorder(self, root, result):
        if not root:
            return
        self.inorder(root.left, result)
        result.append(root.val)
        self.inorder(root.right, result)

也可以进一步缩小使用的空间，每次记录当前遍历的前一个值，比较当前值和前一个值的大小，如果小于等于前一个值，那么就应该返回false。

class Solution:
    def isValidBST(self, root: TreeNode) -> bool:
        stack, inorder = [], float('-inf')
        
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            # 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if root.val <= inorder:
                return False
            inorder = root.val
            root = root.right

        return True

时间复杂度O(n)，空间复杂度O(n)。
思路2：递归
根据二叉搜索树的定义，我们可以知道二叉搜索树的左右子树都是二叉搜索树，也就是说，左子树的值都比根小，右子树的值都比根节点大。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        return self.isBST(root, float('-inf'), float('inf'))

    def isBST(self, root, min, max):
        if not root:
            return True
        if root.val <= min or root.val >= max:
            return False
        else:
            if not self.isBST(root.left, min, root.val):
                return False
            if not self.isBST(root.right, root.val, max):
                return False
        return True

时间复杂度O(n)，空间复杂度O(n)。递归方法的空间复杂度计算：递归函数在递归过程中需要为每一层递归函数分配栈空间，所以这里需要额外的空间且该空间取决于递归的深度，即二叉树的高度。最坏情况下二叉树为一条链，树的高度为 n ，递归最深达到 n 层，故最坏情况下空间复杂度为 O(n)。

通过这两段代码可以学习无限大和无限小的写法。