[每日一题] 130. 验证二叉搜索树(BST树、递归、Morris 遍历、多方法）

1. 题目来源

链接：验证二叉搜索树
来源：LeetCode

2. 题目说明

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

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

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

示例1：

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

示例2：

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

3. 题目解析

方法一：BST性质、递归解法

就是利用其本身性质来做，即左<根<右，初始化时带入系统最大值和最小值，在递归过程中换成它们自己的节点值，用 long 代替 int 就是为了包括 int 的边界条件，代码如下：

参见代码如下：

// 执行用时 :16 ms, 在所有 C++ 提交中击败了76.80%的用户
// 内存消耗 :20.9 MB, 在所有 C++ 提交中击败了13.68%的用户

/**
 * 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 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。去掉等号的条件则相当于去掉了这种限制条件。

下面来看使用中序遍历来做，这种方法思路很直接，通过中序遍历将所有的节点值存到一个数组里，然后再来判断这个数组是不是无重复且升序的即可。在for函数内部若 vt[i] ≥ vt[i+1]，返回 false 即可。

参见代码如下：

// 执行用时 :16 ms, 在所有 C++ 提交中击败了76.80%的用户
// 内存消耗 :21.2 MB, 在所有 C++ 提交中击败了5.12%的用户
/**
 * 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) {
        if (!root) 
            return true;
        vector<int> vt;
        inorder(root, vt);
        for (int i = 0; i < vt.size() - 1; ++i) {
            if (vt[i] >= vt[i + 1]) 
                return false;
        }
        return true;
    }
    void inorder(TreeNode* root, vector<int>& vt) {
        if (!root) return;
        inorder(root->left, vt);
        vt.push_back(root->val);
        inorder(root->right, vt);
    }
};

方法三：中序遍历unique()去重解法

只是单纯的练练unique()的熟练度，思路和方法二一致

参见代码如下：

// 执行用时 :28 ms, 在所有 C++ 提交中击败了10.98%的用户
// 内存消耗 :21.4 MB, 在所有 C++ 提交中击败了5.03%的用户

/**
 * 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:
    vector<int> vt;
    void Inorder(TreeNode* root) {
		if (root) {
			Inorder(root->left);
			vt.push_back(root->val);
			Inorder(root->right);
		}
	}

    bool isValidBST(TreeNode* root) {
        Inorder(root);
        vector<int> tmp(vt.begin(), vt.end());
        sort(vt.begin(), vt.end());
        unique(vt.begin(), vt.end());
        vector<int>::iterator new_end = unique(vt.begin(), vt.end());
        vt.erase(new_end, vt.end());
        if (vt == tmp)
            return true;
        else 
            return false;
    }
};

方法四：方法二修改进阶、直接比较新老节点解法

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

参见代码如下：

// 执行用时 :8 ms, 在所有 C++ 提交中击败了98.82%的用户
// 内存消耗 :20.7 MB, 在所有 C++ 提交中击败了25.55%的用户

/**
 * 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) {
        TreeNode *pre = NULL;
        return inorder(root, pre);
    }
    bool inorder(TreeNode* node, TreeNode*& pre) {
        if (!node) 
            return true;
        bool res = inorder(node->left, pre);
        if (!res) 
            return false;
        if (pre) {
            if (node->val <= pre->val) 
                return false;
        }
        pre = node;
        return inorder(node->right, pre);
    }
};

方法五：非递归、利用栈进行中序遍历

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

参见代码如下：

// 执行用时 :16 ms, 在所有 C++ 提交中击败了76.80%的用户
// 内存消耗 :20.7 MB, 在所有 C++ 提交中击败了22.94%的用户
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;
            }
            p = s.top(); s.pop();
            if (pre && p->val <= pre->val) 
                return false;
            pre = p;
            p = p->right;
        }
        return true;
    }
};

方法六：Morris 遍历

最后还有一种方法，由于中序遍历还有非递归且无栈的实现方法，称之为 Morris 遍历，可以参考博主之前的博客 [杂谈] 13. O(1)空间的 Morris法遍历二叉树，这种实现方法虽然写起来比递归版本要复杂的多，但是好处在于是 O(1) 空间复杂度。

参见代码如下：

// 执行用时 :12 ms, 在所有 C++ 提交中击败了92.89%的用户
// 内存消耗 :20.5 MB, 在所有 C++ 提交中击败了59.08%的用户.

/**
 * 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) {
        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;
    }
};