leetcode：98. 判断是不是二叉搜索树

OceanStar的学习笔记

已于 2022-06-27 13:25:42 修改

阅读量339

点赞数

分类专栏：算法与数据结构

于 2022-04-25 17:14:20 首次发布

原文链接：https://leetcode-cn.com/problems/validate-binary-search-tree/

版权

leetcode

算法与数据结构专栏收录该内容

1135 篇文章 85 订阅

订阅专栏

题目解析

leetcode

题目描述

在这里插入图片描述

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) {

    }
};

题目解析

递归套路

如果一棵树是二叉搜索树，那么必须满足如下条件：

它的左右子树为二叉搜索树
左子树上所有节点的值均小于它的根节点的值
右子树上所有节点的值均大于它的根节点的值；

所以对于root节点，它必须知道每棵子树的如下信息：

当前子树是不是二叉搜索树
当前子树的最大值、最小值（因为一棵树即可能是某棵树的左子树，也可能是另一棵树的右子树）

因此，定义一个Info：

struct Info{
        bool isBST;
        int min;
        int max;
        explicit  Info(bool isBST, int min, int max) : isBST(isBST), min(min), max(max){}
    };

递归求解：

 std::shared_ptr<Info> process(TreeNode* root){
        if(root == nullptr){
            return nullptr;
        }
        
        auto leftInfo = process(root->left);
        auto rightInfo = process(root->right);
        int max = root->val, min = root->val;
        if(leftInfo != nullptr){
            max = std::max(max, leftInfo->max);
            min = std::min(min, leftInfo->min);
        }
        if(rightInfo != nullptr){
            max = std::max(max, rightInfo->max);
            min = std::min(min, rightInfo->min);
        }
        bool isBST = false;
        if(
                (leftInfo== nullptr ? true: leftInfo->isBST)
                &&
                (rightInfo== nullptr ?true:rightInfo->isBST)
                &&
                (leftInfo== nullptr?true:leftInfo->max<root->val)
                &&
                (rightInfo== nullptr?true:rightInfo->min>root->val)
                ) {
            isBST=true;
        }
        return std::make_shared<Info>(isBST, min, max);
    }

调用上面的递归：

 bool isValidBST(TreeNode* root) {
        if(root == nullptr){
            return true;
        }
        return process(root)->isBST;
    }

整体代码如下：

class Solution {
    struct Info{
        bool isBST;
        int min;
        int max;
        explicit  Info(bool isBST, int min, int max) : isBST(isBST), min(min), max(max){}
    };
    
    std::shared_ptr<Info> process(TreeNode* root){
        if(root == nullptr){
            return nullptr;
        }
        
        auto leftInfo = process(root->left);
        auto rightInfo = process(root->right);
        int max = root->val, min = root->val;
        if(leftInfo != nullptr){
            max = std::max(max, leftInfo->max);
            min = std::min(min, leftInfo->min);
        }
        if(rightInfo != nullptr){
            max = std::max(max, rightInfo->max);
            min = std::min(min, rightInfo->min);
        }
        bool isBST = false;
        if(
                (leftInfo== nullptr ? true: leftInfo->isBST)
                &&
                (rightInfo== nullptr ?true:rightInfo->isBST)
                &&
                (leftInfo== nullptr?true:leftInfo->max<root->val)
                &&
                (rightInfo== nullptr?true:rightInfo->min>root->val)
                ) {
            isBST=true;
        }
        return std::make_shared<Info>(isBST, min, max);
    }
    
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr){
            return true;
        }
        return process(root)->isBST;
    }
};

在这里插入图片描述

Morris遍历

二叉搜索树的中序遍历有序

class Solution {
public:
    bool isValidBST(TreeNode* head) {
        if(head == nullptr){
            return nullptr;
        }
        
        TreeNode *curr = head;
        TreeNode *mostRight = nullptr;
        int pre = INT32_MIN;
        bool ans = true;
        
        while (curr != nullptr){
            mostRight = curr->left;
            if(mostRight != nullptr){
                while (mostRight->right != nullptr && mostRight->right != curr){
                    mostRight = mostRight->right;
                }
                if(mostRight->right == nullptr){
                    mostRight->right = curr;
                    curr = curr->left;
                    continue;
                }else{
                    mostRight->right = nullptr;
                }
            }
            
            if(pre != INT32_MIN && pre >= curr->val){
                ans = false;
            }
            pre = curr->val;
            curr = curr->right;
        }
        return ans;
    }
};

递归

如果一棵树是二叉搜索树，那么必须满足如下条件：

如果该二叉树的左子树不为空，则左子树上所有节点的值均小于它的根节点的值
若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
它的左右子树也为二叉搜索树。

因此，我们可以设计一个递归函数helper(root, lower, upper)来递归判断，函数表示以root为根的子树，判断子树中所有节点的值是否在(l，r)的范围内（注意是开区间）。

如果root节点的值val不再(l，r)范围内说明不满足条件直接返回，否则递归调用它的左右子树是否满足。如果都满足才说明这是一棵二叉搜索树。
在递归调用左子树时，需要把upper改成root.val，即helper(root.left, lower, root.val)，因为左子树里所有节点的值均小于它的根节点的值。
在递归调用右子树时，需要把low改成root,val，即helper(root.right, root.val, upper)，因为右子树里所有节点的值均大于它的根节点的值。
函数递归调用的入口为 helper(root, -inf, +inf)， inf 表示一个无穷大的值。

class Solution {
    bool helper(TreeNode *root, long min, long max){
        if(root == NULL){
            return true;
        }
        if (root->val <= min || root->val >= max) return false;
        
        return helper(root->left, min, root->val) && helper(root->right, root->val, max);
    }
public:
    bool isValidBST(TreeNode* root) {
        return helper(root, LONG_MIN, LONG_MAX);
    }
};

在这里插入图片描述

中序遍历

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

   20       20
   /           \
 20           20

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

class Solution {
    void helper(TreeNode *root, std::vector<int> &vals){
        if(root == NULL){
            return ;
        }
     
        helper(root->left, vals);
        vals.emplace_back(root->val);
        helper(root->right, vals);
    }
public:
    bool isValidBST(TreeNode* root) {
        if (!root) return true;
        vector<int> vals;
        helper(root, vals);
        int len = vals.size();
        for (int i = 0; i < len - 1; ++i) {
            if(vals[i] >= vals[i + 1]){
                return false;
            }
        }
        return true;
    }
};

但是如果树很大，可能没有那么多的空间来存储。可以换个思路。

还是中序遍历，每次遍历到一个节点时，都和上一个节点比较
curr->val必须要大于 pre.val，才是一颗二叉搜索树，才能进行下一个递归；否则，直接返回false

class Solution {
    bool helper(TreeNode *root,  TreeNode *&pre){
        if(root == NULL){
            return true;  
        }
        bool res = helper(root->left, pre);
        if(res == false){
            return false;
        }
        if(pre != NULL){
            if(pre->val >= root->val){
                return false;
            }
        }
        pre = root;
        return helper(root->right, pre);
    }
public:
    bool isValidBST(TreeNode* root) {
        TreeNode *pre = NULL;
        return helper(root, pre);
    }
};

中序遍历的迭代写法：

class Solution {

public:
    bool isValidBST(TreeNode* root) {
        std::stack<TreeNode *>s;
        TreeNode *curr = root, *pre = NULL;
        while (curr || !s.empty()){
            while (curr){
                s.push(curr);
                curr = curr->left;
            }
            curr = s.top(); s.pop();
            if(pre && curr->val <= pre->val){
                return false;
            }
            pre = curr;
            curr = curr->right;
        }
        return true;
    }
};