98. 验证二叉搜索树

98. 验证二叉搜索树

题目描述

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

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

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

示例 1:

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

示例 2:

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

---

题解：

递归。

二叉搜索树有一个特性：中序遍历序列是递增序列。

所以可以中序遍历二叉树，实时检查当前节点的值是否大于中序遍历前一个节点的值。

写法一：

直接递归。

时间复杂度：$O(n)$

额外空间复杂度：$O(n)$

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    long pre;
    bool inorder( TreeNode* root ) {
        if ( root ) {
            if ( !inorder( root->left ) ) return false;
            if ( pre >= root->val ) return false;
            pre = root->val;
            if ( !inorder( root->right ) ) return false;
        }
        return true;
    }
    bool isValidBST(TreeNode* root) {
        pre = LONG_MIN;
        return inorder( root );
    }
};
/*
时间：4ms，击败：99.83%
内存：21MB，击败：64.89%
*/

写法二：

迭代模拟递归。

时间复杂度：$O(n)$

额外空间复杂度：$O(n)$

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> stk;
        long pre = LONG_MIN;
        while ( stk.size() || root ) {
            while ( root ) {
                stk.push( root );
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            if ( pre >= root->val ) return false;
            pre = root->val;
            root = root->right;
        }
        return true;
    }
};
/*
时间：12ms，击败：90.40%
内存：21.1MB，击败：53.74%
*/

写法三：Morris遍历

时间复杂度：$O(n)$

额外空间复杂度：$O(1)$

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    using LL = long long;
    bool isValidBST(TreeNode* root) {
        LL pre = (LL)INT_MIN - 1;
        TreeNode *mostright = nullptr;
        bool flag = true;
        while ( root ) {
            mostright = root->left;
            if ( mostright ) {
                while ( mostright->right && mostright->right != root )
                    mostright = mostright->right;
                if ( !mostright->right ) {
                    mostright->right = root;
                    root = root->left;
                    continue;
                } else mostright->right = nullptr;
            }
            if ( pre >= root->val ) flag = false;
            pre = root->val;
            root = root->right;
        }
        return flag;
    }
};

注意：Morris 遍历中间不能返回 false ，如果中间返回，树中被改变的节点没有恢复，销毁时会出问题，这个 bug 搞我半天。。。

AddressSanitizer:DEADLYSIGNAL
=================================================================
==42==ERROR: AddressSanitizer: stack-overflow on address 0x7ffd1d2e1ff8 (pc 0x00000037aed9 bp 0x7ffd1d2e2010 sp 0x7ffd1d2e2000 T0)
==42==ABORTING