LeetCode: Validate Binary Search Tree

Title:

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

Assume a BST is defined as follows:

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

思路：（1）第一下就是使用递归比较一个节点是否比左子节点大，比右子节点小。但是一想这是有问题的，如

5
/ \
4 10
/ \
3 11

这样的树是符合我所想的递归，但是不符合二叉搜索树的要求。

但是网上有人根据这个类似的想法，也是使用递归。与前面错误的递归相反，这个递归想法是对每个节点，看是否符合当前传递的左右值，而不是看其左右子节点。网上很用人用了INT_MAX和INT_MIN来辅助解决这道题，即遍历时记录一个当前允许的最大值和最小值。但是并不能通过测试，因为LeetCode新增了测试用例

Input:	{-2147483648,#,2147483647}
Output:	false
Expected:	true

/**
* 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) {
return check(root,INT_MIN,INT_MAX);
}
bool check(TreeNode* p , int leftValue, int rightValue){
if(p == NULL)
return true;
return (p->val > leftValue && p->val < rightValue) && check(p->left,leftValue,p->val) && check(p->right,p->val,rightValue);
}
};

（2）使用中序遍历，因此BST必须符合中序遍历是递增的

/**
* 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) {
vector<int> v;
midOrder(v,root);
for (int i = 1 ; i < v.size(); i++){
if (v[i] <= v[i-1])
return false;
}
return true;
}
void midOrder(vector<int> & v, TreeNode* root){
stack<TreeNode*> s;
TreeNode* p = root;
while (p || !s.empty()){
while (p){
s.push(p);
p = p->left;
}
if (!s.empty()){
p = s.top();

v.push_back(p->val);
p = p->right;
s.pop();
}
}
}
};

网上一个更好的，不需要额外O(n)空间的代码

class Solution {
// Keep the previous value in inorder traversal.
public:
TreeNode* pre = NULL;

bool isValidBST(TreeNode* root) {
// Traverse the tree in inorder.
if (root != NULL) {
// Inorder traversal: left first.
if (!isValidBST(root->left)) return false;

// Compare it with the previous value in inorder traversal.
if (pre != NULL && root->val <= pre->val) return false;

// Update the previous value.
pre = root;

// Inorder traversal: right last.
return isValidBST(root->right);
}
return true;
}
};