LeetCode 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:
2
/ \
1 3
Binary tree [2,1,3], return true.

Example 2:
1
/ \
2 3
Binary tree [1,2,3], return false.

题目大意：给出一棵二叉树，判断它是不是二叉搜索树。
解题思路1：根据二叉搜索树的性质，它的中序遍历结果是从小到大依次排序的。所以我们可以保存中序遍历结果然后判断它是不是有序的。根据这种思路写出的代码时间复杂度为O(N)。
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        inOrderTraversal(root, ans);
        return isOrdered(ans);
    }
private:
    vector<int> ans;

    void inOrderTraversal(TreeNode* root, vector<int>& ans) {
        if(root == nullptr) return;
        inOrderTraversal(root->left, ans);
        ans.push_back(root->val);
        inOrderTraversal(root->right, ans);
    }

    bool isOrdered(vector<int> arr) {
        for(int i = 1; i < (int)arr.size();i++) {
            if(arr[i] <= arr[i - 1]) return false;
        }
        return true;
    }
};

解题思路2：对于一棵二叉搜索树来说，当我们遍历到它的根节点root时，我们知道它的左子树所有节点的值一定会在区间INT_MIN和root->val之间，而右子树所有节点的值一定会在root->val和INT_MAX之间。而对于root的右子树的左子树来说，它的所有节点的值一定是在区间[root->val, root->right->val]之间，否则它就不是BST。根据这种思路，我们同样可以在O(N)时间内判断一棵二叉树是否为BST。
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool judge(struct TreeNode* root, long long min, long long max) {
    if (root == NULL) return true;  

    // not in range  
    if (root->val <= min || root->val >= max) return false;   

    // left subtree must be < root->val && right subtree must be > root->val  
    return judge(root->left, min, root->val) && judge(root->right, root->val, max);  
}

bool isValidBST(struct TreeNode* root) {
    return judge(root, LONG_MIN, LONG_MAX);
}