LeetCode: 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

思路：

两种思路：

第一种是使用中序遍历，获得二叉搜索树的排列数组，然后记录下遍历的前一个节点。每个节点均和自己的中序前继比较，如果前继大于或者等于该节点值，那么说明这就不是一个valid的二叉搜索树。

第二种就是按照定义来设计算法，采用自底向上的方法，递归实现。对某一个节点，先求得它的左子树的最大值，最小值，以及左子树是否为valid。再求右子树的最大值，最小值，以及是否为valid。然后再用求得的左边最小值，右边最小值以及该节点的值来更新该节点所代表子树的最小值。同样，用右边最大值，左边最大值，以及该节点的值来更新该节点所代表子树的最大值。

那么该节点所代表的子树是否为vald，取决于左子树，右子树是否为valid，以及左边子树的最大值是否小于该节点值，以及右子树的最小值是否大于该节点值。

代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    bool isValidBSTAux(TreeNode *root, int &minInTree, int &maxInTree)
    {
        if(root == NULL)
        {
            minInTree = INT_MAX;
            maxInTree = INT_MIN;
            return true;
        }
        int leftMin, rightMin, rightMax, leftMax;
        bool leftValid = isValidBSTAux(root->left, leftMin, leftMax);
        bool rightValid = isValidBSTAux(root->right, rightMin, rightMax);
        
        minInTree = min(leftMin, rightMin);
        minInTree = min(minInTree, root->val);
        maxInTree = max(leftMax, rightMax);
        maxInTree = max(maxInTree, root->val);
        
        bool ret = leftValid && rightValid;
        
        if(root->left)
            ret = ret && (leftMax < root->val);
        
        if(root->right)
            ret = ret && (rightMin > root->val);
        return ret;
    }
    
    bool inOrder(TreeNode * root)
    {
         stack<TreeNode *> s;
        TreeNode *p = root, *prev = NULL;
        while(!s.empty() || p)
        {
            if(p)
            {
                s.push(p);
                p = p->left;
            }
            else
            {
                p = s.top();
                s.pop();
                if(prev != NULL && prev->val >= p->val)
                    return false;
                prev = p;
                p = p->right;
            }
        }
        return true;
    }
    
public:
    bool isValidBST(TreeNode *root) {
        /*
        return inOrder(root); 
        */
      
        int max = INT_MIN, min = INT_MAX;
        return isValidBSTAux(root, min, max);
    }
};