Question

有人可以告诉我为什么这不起作用？这似乎对我来说是正确的

请有人看看这个。

我无法找到我的错误。

bool checkbst(node* root,int minValue,int maxValue)
{
   if(root==NULL)
   {

       return true;
   }
   else if(((root->data)>(minValue))&&
           ((root->data)>(maxValue))&&
           (checkbst(root->left,minValue,root->data))&&
           (checkbst(root->right,root->data,maxValue)))
   {

       return true;
   }
   else
   {

     return false;
   }
}

void isbst(node* root)
{
   if( checkbst(root,INT_MIN,INT_MAX))
   {
       cout<<"the tree is bst";
   }
}

Answer 1

checkbst中有拼写错误，您正在检查

((root->data)>(minValue))&&((root->data)>(maxValue))

虽然它可能应该是

((root->data)>(minValue))&&((root->data)<(maxValue))

（注意“小于”的标志）。

Answer 2

您的代码验证密钥是否在某个范围内，但是它不会验证子代是否满足与根相关的bst条件。也就是说，左子树中的键必须小于根，而右键中的键更大。在进行涉及子树的任何比较之前，您应该检查子项是否为空。

此版本应该有效：

bool checkbst(node* root, int minValue,int maxValue)
{
  if (root == nullptr) 
    return true;

  if (not (root->data >= minValue && root->data <= maxvalue))
    return false;

  if (root->left)
    {
      if (root->data < root->left->data)
        if (not checkbst(root->left, minValue, maxValue))
          return false;
      else 
        return false;
    }

  // here the left subtree has been checked
  if (root->right)
    {
      if (root->data < root->right->data)
        return checkbst(root->right, minValue, maxValue);
      else
        return false;
    }

  return true; // everything is ok
}

Answer 3

我已经检查过您的错误代码有一些错误，但有更好的方法可以做到这一点。您只需按顺序遍历给定树并将其存储在数组中，然后检查数组中的元素是否已排序。如果元素被排序，那么它是二进制搜索树，否则它将是二叉树（这是二叉树和二叉搜索树之间的一种基本差异）。

您的代码中存在一个小错误

((root->data)>(maxValue))

应该是

((root->data)<(maxValue))

Answer 4

这是O（n）时间复杂度和O（1）空间的解决方案。它使用顺序树遍历来确认树是根据BST规则排序的，但它不依赖于维护顺序遍历节点的辅助数组。但是，由于它确实依赖于递归，因此它对堆栈的使用（即堆栈深度）可以达到O（logn）。

struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
};

bool isBSTHelper(Node* root, int& min, int& max)
{
    if (nullptr == root)
    {
        max = numeric_limits<int>::min(); // has meaning for LHS traversal.
        min = numeric_limits<int>::max(); // has meaning for RHS traversal.
        return true;
    }

    int lhsMax;
    int lhsMin;
    if (!isBSTHelper(root->left, lhsMin, lhsMax) ||
        lhsMax >= root->data)
    {
        return false;
    }

    int rhsMax;
    int rhsMin;
    if (!isBSTHelper(root->right, rhsMin, rhsMax) ||
        rhsMin <= root->data)
    {
        return false;
    }

    min = std::min(lhsMin, root->data);
    max = std::max(rhsMax, root->data);

    return true;
}

bool isBST(Node* root)
{
    int min;
    int max;
    return isBSTHelper(root, min, max);
}

用于检查二叉树是否为二叉搜索树或不工作的函数

4 个答案: