LeetCode（98）： 验证二叉搜索树

Medium！

题目描述：

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

一个二叉搜索树具有如下特征：

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

示例 1:

1输入:
2    2
3   / \
4  1   3
5输出: true

示例 2:

1输入:
2    5
3   / \
4  1   4
5     / \
6    3   6
7输出: false
8解释: 输入为: [5,1,4,null,null,3,6]。
9     根节点的值为 5 ，但是其右子节点值为 4 。

解题思路：

这道验证二叉搜索树有很多种解法，可以利用它本身的性质来做，即左<根<右，也可以通过利用中序遍历结果为有序数列来做，下面我们先来看最简单的一种，就是利用其本身性质来做，初始化时带入系统最大值和最小值，在递归过程中换成它们自己的节点值，用long代替int就是为了包括int的边界条件，代码如下：

C++ 解法一：

1// Recursion without inorder traversal
2class Solution {
3public:
4    bool isValidBST(TreeNode *root) {
5        return isValidBST(root, LONG_MIN, LONG_MAX);
6    }
7    bool isValidBST(TreeNode *root, long mn, long mx) {
8        if (!root) return true;
9        if (root->val <= mn || root->val >= mx) return false;
10        return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
11    }
12};

这题实际上简化了难度，因为一般的二叉搜索树是左<=根<右，而这道题设定为左<根<右，那么就可以用中序遍历来做。因为如果不去掉左=根这个条件的话，那么下边两个数用中序遍历无法区分：

   20       20
   /           \
 20           20

它们的中序遍历结果都一样，但是左边的是BST，右边的不是BST。去掉等号的条件则相当于去掉了这种限制条件。下面我们来看使用中序遍历来做，这种方法思路很直接，通过中序遍历将所有的节点值存到一个数组里，然后再来判断这个数组是不是有序的，代码如下：

C++ 解法二：

1// Recursion
2class Solution {
3public:
4    bool isValidBST(TreeNode *root) {
5        if (!root) return true;
6        vector<int> vals;
7        inorder(root, vals);
8        for (int i = 0; i < vals.size() - 1; ++i) {
9            if (vals[i] >= vals[i + 1]) return false;
10        }
11        return true;
12    }
13    void inorder(TreeNode *root, vector<int> &vals) {
14        if (!root) return;
15        inorder(root->left, vals);
16        vals.push_back(root->val);
17        inorder(root->right, vals);
18    }
19};

下面这种解法跟上面那个很类似，都是用递归的中序遍历，但不同之处是不将遍历结果存入一个数组遍历完成再比较，而是每当遍历到一个新节点时和其上一个节点比较，如果不大于上一个节点那么则返回false，全部遍历完成后返回true。代码如下：

C++ 解法三：

1// Still recursion
2class Solution {
3public:
4    TreeNode *pre;
5    bool isValidBST(TreeNode *root) {
6        int res = 1;
7        pre = NULL;
8        inorder(root, res);
9        if (res == 1) return true;
10        else false;
11    }
12    void inorder(TreeNode *root, int &res) {
13        if (!root) return;
14        inorder(root->left, res);
15        if (!pre) pre = root;
16        else {
17            if (root->val <= pre->val) res = 0;
18            pre = root;
19        }
20        inorder(root->right, res);
21    }
22};

当然这道题也可以用非递归来做，需要用到栈，因为中序遍历可以非递归来实现，所以只要在其上面稍加改动便可，代码如下：

C++ 解法四：

1// Non-recursion with stack
2class Solution {
3public:
4    bool isValidBST(TreeNode* root) {
5        stack<TreeNode*> s;
6        TreeNode *p = root, *pre = NULL;
7        while (p || !s.empty()) {
8            while (p) {
9                s.push(p);
10                p = p->left;
11            }
12            TreeNode *t = s.top(); s.pop();
13            if (pre && t->val <= pre->val) return false;
14            pre = t;
15            p = t->right;
16        }
17        return true;
18    }
19};

最后还有一种方法，由于中序遍历还有非递归且无栈的实现方法，称之为Morris遍历，可以参考http://www.cnblogs.com/grandyang/p/4297300.html,这种实现方法虽然写起来比递归版本要复杂的多，但是好处在于是O(1)空间复杂度，参见代码如下：

C++ 解法五:

1class Solution {
2public:
3    bool isValidBST(TreeNode *root) {
4        if (!root) return true;
5        TreeNode *cur = root, *pre, *parent = NULL;
6        bool res = true;
7        while (cur) {
8            if (!cur->left) {
9                if (parent && parent->val >= cur->val) res = false;
10                parent = cur;
11                cur = cur->right;
12            } else {
13                pre = cur->left;
14                while (pre->right && pre->right != cur) pre = pre->right;
15                if (!pre->right) {
16                    pre->right = cur;
17                    cur = cur->left;
18                } else {
19                    pre->right = NULL;
20                    if (parent->val >= cur->val) res = false;
21                    parent = cur;
22                    cur = cur->right;
23                }
24            }
25        }
26        return res;
27    }
28};