在二叉搜索树上找到大于 X 的第一个键

Question

BST 中元素的后继者是该元素在 BST 中的后继者 由中序遍历确定的排序顺序。寻找 当每个节点都有一个指向其父节点的指针时出现后继 在 CLRS 的算法教科书中（麻省理工学院的算法简介 按）。

如果结构中没有parent，有没有办法找到大于 X 的第一个值？喜欢：

typedef struct tree tree;
struct tree{
   int value;
   tree *left;
   tree *right;
};

//Function:  

tree *find_first_bigger(tree *t, int x){}  

我尝试过使用：

tree *find_first_bigger(tree *t, int x){
   if(t == NULL)
      return NULL;

   if((*t)->value > x)
      find_first_bigger((*t)->left, x);

   else if((*t)->value < x)
      find_first_bigger((*t)->right), x);
   else if((*t)->value == x){
      if((*t)->right != NULL) 
         return tree_first_bigger((*t)->right);
      else
         return tree;
   }
}  

在这个例子中（它使用字母，但没有问题），如果我尝试搜索大于N的第一个（它应该返回我O）但它返回我N。

Answer 1

你已经完成了 90% 的工作。请允许我完成剩下的 10%。

由于 t 是一个指向结构的指针，你应该使用 t->left 而不是 (*t)->left 并且在访问 right 和 value 结构的字段。

现在，只需将您的函数修改为：

将此添加为函数的第一行

static tree* PTR=NULL;

将第二个if条件修改为：

if(t->value > x)
 {
     PTR=t;
     find_first_bigger(t->left, x);
 }

将第二个else if条件修改为：

else if(t->value == x)
{
  if(t->right != NULL)
     {
         t=t->right;
         while(t->left!=NULL)
            t=t->left;
         return t;
     }
  else return PTR;
}

因此正确的函数是

tree *find_first_bigger(tree *t, int x)
{
   static tree* PTR=NULL;
   if(t == NULL)
      return NULL;
   if(t->value > x)
     {
         PTR=t;
         find_first_bigger(t->left, x);
     }
   else if(t->value < x)
       find_first_bigger(t->right, x);
   else if(t->value == x)
    {
      if(t->right != NULL)
         {
             t=t->right;
             while(t->left!=NULL)
                t=t->left;
             return t;
         }
      else return PTR;
   }
}

在主函数中，如果返回的指针为NULL，这意味着：键本身就是最大的键。请随意查询。

Answer 2

我没有对此进行测试，但我认为它应该可以工作。让我知道它是否错了。 //c++ 11

 #include<iostream>
 using namespace std;
 struct BSTNode{
     int val;
     BSTNode* left;
     BSTNode* right;
 };


 int FindJustLarger(BSTNode*& node, int token, int sofarlarge){
    // for invalid inputs it will return intial value of sofarlarge
    // By invalid input I mean token > largest value in BST
    if(node == nullptr)
        return sofarlarge;

    else if(node->val > token){
        sofarlarge = node->val;
        return FindJustLarger(node->left, token, sofarlarge);}

    else
        return FindJustLarger(node->right, token, sofarlarge);}

int main(){
    BSTNode* head = new BSTNode{5, nullptr, nullptr};
    FindJustLarger(head, 5, NULL);
    delete head;
    return 0;}

Answer 3

您可以在代码中进行一些更改：

• 您必须从递归调用中返回值

• 如果未找到该值，则返回NULL。这意味着如果 t->right == NULL 在最后一个 if 上，则返回 NULL。

• 往左边走时，如果那里没有找到值，答案肯定是节点本身。对于N，它是我们左转的最后一个节点：O。如果是P，答案就是T 本身。

完成所有这些更改后，代码应如下所示：

tree *find_first_bigger(tree *t, int x){
   if(t == NULL)
      return NULL;

   if(t->value > x) {
      tree *answer = find_first_bigger(t->left, x);
      if (answer != NULL) 
          return answer;
      return t;
   } else if(t->value < x) {
      return find_first_bigger(t->right, x);
   } else if(t->value == x) {
      if (t->right != NULL)
          return tree_first_bigger(t->right);
      return NULL;
   }
}  

你可以找到我用来测试in this gist的整个代码。

Answer 4

在您的问题中，您似乎表示要找出给定值“x”的 InOrderSuccessor()。

如果树中不一定存在“x”，我们需要更改算法。鉴于您提供的示例和问题陈述，这里是在 BST 中查找下一个元素的代码。

关键案例有：

• 不存在更大的元素，因为“x”是最大的。
• 'x' 有一个正确的孩子？
• YES：获取 x 的右子树的最左子节点。
• 否：返回父级。

关键观察是我们不会更新父指针，无论何时我们在树中向右走。

  tree *ptr = root;
  tree *prnt = NULL;
  while (ptr != NULL) {
      if (x == ptr->key) {
          if (ptr->right != NULL) {
              return GetLeftMostChild(ptr->right);
          } else {
              return prnt;
          }
      } else if (x > ptr->key) {
          ptr = ptr->right;
      } else {
          prnt = ptr;
          ptr = ptr->left;
      }
  }

这里是leftMostChild()的定义

tree *GetLeftMostChild(tree *n) {
    tree *ptr = n;
    while (ptr->left != NULL) {
        ptr = ptr->left;
    }
    return ptr;
}