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

题目解析

题目描述

在这里插入图片描述
在这里插入图片描述

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;
    }
};
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值