Medium！
題目描述：
給定一個二叉樹，判斷其是否是一個有效的二叉搜索樹。
一個二叉搜索樹具有如下特征：
- 節點的左子樹只包含小於當前節點的數。
- 節點的右子樹只包含大於當前節點的數。
- 所有左子樹和右子樹自身必須也是二叉搜索樹。
示例 1:
輸入:
2
/ \
1 3
輸出: true
示例 2:
輸入:
5
/ \
1 4
/ \
3 6
輸出: false
解釋: 輸入為: [5,1,4,null,null,3,6]。
根節點的值為 5 ，但是其右子節點值為 4 。
解題思路：
這道驗證二叉搜索樹有很多種解法，可以利用它本身的性質來做，即左<根<右，也可以通過利用中序遍歷結果為有序數列來做，下面我們先來看最簡單的一種，就是利用其本身性質來做，初始化時帶入系統最大值和最小值，在遞歸過程中換成它們自己的節點值，用long代替int就是為了包括int的邊界條件，代碼如下：
C++ 解法一：
// Recursion without inorder traversal
class Solution {
public:
bool isValidBST(TreeNode *root) {
return isValidBST(root, LONG_MIN, LONG_MAX);
}
bool isValidBST(TreeNode *root, long mn, long mx) {
if (!root) return true;
if (root->val <= mn || root->val >= mx) return false;
return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
}
};
這題實際上簡化了難度，因為一般的二叉搜索樹是左<=根<右，而這道題設定為左<根<右，那么就可以用中序遍歷來做。因為如果不去掉左=根這個條件的話，那么下邊兩個數用中序遍歷無法區分：
20 20
/ \
20 20
它們的中序遍歷結果都一樣，但是左邊的是BST，右邊的不是BST。去掉等號的條件則相當於去掉了這種限制條件。下面我們來看使用中序遍歷來做，這種方法思路很直接，通過中序遍歷將所有的節點值存到一個數組里，然后再來判斷這個數組是不是有序的，代碼如下：
C++ 解法二：
// Recursion
class Solution {
public:
bool isValidBST(TreeNode *root) {
if (!root) return true;
vector<int> vals;
inorder(root, vals);
for (int i = 0; i < vals.size() - 1; ++i) {
if (vals[i] >= vals[i + 1]) return false;
}
return true;
}
void inorder(TreeNode *root, vector<int> &vals) {
if (!root) return;
inorder(root->left, vals);
vals.push_back(root->val);
inorder(root->right, vals);
}
};
下面這種解法跟上面那個很類似，都是用遞歸的中序遍歷，但不同之處是不將遍歷結果存入一個數組遍歷完成再比較，而是每當遍歷到一個新節點時和其上一個節點比較，如果不大於上一個節點那么則返回false，全部遍歷完成后返回true。代碼如下：
C++ 解法三：
// Still recursion
class Solution {
public:
TreeNode *pre;
bool isValidBST(TreeNode *root) {
int res = 1;
pre = NULL;
inorder(root, res);
if (res == 1) return true;
else false;
}
void inorder(TreeNode *root, int &res) {
if (!root) return;
inorder(root->left, res);
if (!pre) pre = root;
else {
if (root->val <= pre->val) res = 0;
pre = root;
}
inorder(root->right, res);
}
};
當然這道題也可以用非遞歸來做，需要用到棧，因為中序遍歷可以非遞歸來實現，所以只要在其上面稍加改動便可，代碼如下：
C++ 解法四：
// Non-recursion with stack
class Solution {
public:
bool isValidBST(TreeNode* root) {
stack<TreeNode*> s;
TreeNode *p = root, *pre = NULL;
while (p || !s.empty()) {
while (p) {
s.push(p);
p = p->left;
}
TreeNode *t = s.top(); s.pop();
if (pre && t->val <= pre->val) return false;
pre = t;
p = t->right;
}
return true;
}
};
最后還有一種方法，由於中序遍歷還有非遞歸且無棧的實現方法，稱之為Morris遍歷，可以參考http://www.cnblogs.com/grandyang/p/4297300.html,這種實現方法雖然寫起來比遞歸版本要復雜的多，但是好處在於是O(1)空間復雜度，參見代碼如下：
C++ 解法五:
class Solution {
public:
bool isValidBST(TreeNode *root) {
if (!root) return true;
TreeNode *cur = root, *pre, *parent = NULL;
bool res = true;
while (cur) {
if (!cur->left) {
if (parent && parent->val >= cur->val) res = false;
parent = cur;
cur = cur->right;
} else {
pre = cur->left;
while (pre->right && pre->right != cur) pre = pre->right;
if (!pre->right) {
pre->right = cur;
cur = cur->left;
} else {
pre->right = NULL;
if (parent->val >= cur->val) res = false;
parent = cur;
cur = cur->right;
}
}
}
return res;
}
};