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

    有效 二叉搜索树定义如下：

    • 节点的左子树只包含 小于 当前节点的数。
    • 节点的右子树只包含 大于 当前节点的数。
    • 所有左子树和右子树自身必须也是二叉搜索树。

    示例 1：
    输入：root = [2,1,3]
    输出：true

    示例 2：
    输入：root = [5,1,4,null,null,3,6]
    输出：false
    解释：根节点的值是 5 ，但是右子节点的值是 4 。
    �
    二叉搜索树有个特性：中序遍历结果是个升序序列
    可以利用此特性通过验证树的中序遍历结果是否是升序序列来间接判断树是否二叉搜索树

    1. /**
    2.  * 利用二叉搜索树中序遍历结果是个升序序列的特性
    3.  * 通过验证树的中序遍历结果是否是升序序列来间接判断树是否二叉搜索树
    4.  *
    5.  * @param root
    6.  * @return
    7.  */
    8. public boolean isValidBST(TreeNode root) {
    9.     ArrayList<Integer> valList = new ArrayList<>();
    10.     inOrder(root, valList);
    11.     // 验证中序遍历结果是否是一个升序序列
    12.     boolean isValid = true;
    13.     int preVal = valList.get(0);
    14.     for (int i = 1; i < valList.size(); i++) {
    15.         int curVal = valList.get(i);
    16.         if (curVal <= preVal) {
    17.             isValid = false;
    18.             break;
    19.         }
    20.         preVal = curVal;
    21.     }
    22.     return isValid;
    23. }
    25. /**
    26.  * 树的中序遍历
    27.  * @param node
    28.  * @param result
    29.  */
    30. public void inOrder(TreeNode node, ArrayList<Integer> result) {
    31.     if (node == null) {
    32.         return;
    33.     }
    34.     inOrder(node.left, result);
    35.     result.add(node.val);
    36.     inOrder(node.right, result);
    37. }

    �
    假设有一棵二叉搜索树：

    1.             4            
    2.          /     \         
    3.       1           6      
    4.     /   \       /   \    
    5.   0       2   5       7  
    6.                        \ 
    7.                         8

    �其中序遍历结果：[0, 1, 2, 4, 5, 6, 7, 8]
    左子树：

    1.       1             
    2.     /   \        
    3.   0       2

    位于中序遍历结果序列 [0~4) 之间
    右子树：

    1.     6      
    2.   /   \    
    3. 5      7  
    4.          \ 
    5.            8

    位于中序遍历结果序列 (4, 8] 之间
    右子树的中序遍历结果序列：[5, 6, 7, 8]
    左子树：

    1. 5

    位于中序遍历结果序列 [5, 6) 之间
    右子树：

    1.  7  
    2.   \ 
    3.    8

    位于中序遍历结果序列 (6,8] 之间

    那么是否可以不断的通过判断节点的值是否位于某个范围值之间从而判断树是否满足二叉搜索树的标准？

    1. public boolean isValidBST(TreeNode root) {
    2.     return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    3. }
    5. public boolean isValidBST(TreeNode node, long min, long max) {
    6.     if (node == null) {
    7.         return true;
    8.     }
    9.     // 若当前根节点的值小于等于最小值 或者 大于等于最大值 则表示不符合二叉搜索树
    10.     if (node.val <= min || node.val >= max) {
    11.         return false;
    12.     }
    13.     // 左子树的最大值不能大于当前根节点 右子树的最小值不能小于当前根节点
    14.     return isValidBST(node.left, min, node.val) && isValidBST(node.right, node.val, max);
    15. }