Question

我正在寻找一种方法来找出BST节点的继承者，而不是使用额外的空间。

Answer 1

要获取给定节点N的inorder后继，我们使用以下规则：

如果N有一个合适的孩子R，那么 inorderSuccessor(N)是最左边的 R。
其他inorderSuccessor(N)是最接近的 M的祖先N（如果存在）这样N就是后来的 M的左孩子。如果没有这样的祖先，则inorderSucessor不存在。

考虑一个示例树：

     A
    / \
   B   C
  / \ 
 D   E
    /
   F

顺序遍历给出：D B F E A C

inorderSuccessor(A) = C C是A右侧孩子最左边的死者。

inorderSuccessor(B) = F F是B右侧孩子最左边的死者。

inorderSuccessor(C) =不存在。

inorderSuccessor(D) = B由于B是D的左子。

inorderSuccessor(E) = A。 E没有合适的孩子，所以我们有方案2.我们转到E的父级B，但E是B的正确代理人，所以我们转移到B的父级A，而B是[{1}}的父级，因此A就是答案。

A = inorderSuccessor(F)由于E是F的左子。

步骤：

Code In Action

Answer 2

以下方法可帮助您确定顺序继承人没有任何父母节点或额外空间

struct node * inOrderSuccessor(struct node *root, struct node *n)
   { 
   //*If the node has a right child, return the smallest value of the right sub tree*

   if( n->right != NULL ) 
      return minValue(n->right); 

   //*Return the first ancestor in whose left subtree, node n lies*
   struct node *succ=NULL;
   while(root) 
   { 
      if(n->datadata < root->data) 
         {
            succ=root; root=root->left; 
         }

      else if(n->data > root->data) 
         root=root->right; 
      else break; 
   } 
  return succ;
 }

我很确定这是对的。如果我错了，请纠正我。谢谢。

Answer 3

如果给定节点有一个正确的孩子 - 转到它，然后迭代地跟随左孩子，直到你到达一个没有左子女的节点N.返回N。

否则，请跟随父母，直到您第一次找到父节点为左子节点。归还这个父母。

Node InOrderSuccessor(Node node) {
    if (node.right() != null) {
        node = node.right()
        while (node.left() != null) 
            node = node.left()
        return node
    } else {
        parent = node.getParent();
        while (parent != null && parent.right() == node) {
            node = parent
            parent = node.getParent()
        }
        return parent
    }
}

Answer 4

如果你可以访问节点的根，那么只需要移动指针，所以没有额外的空间。请参阅this lecture。

在不使用任何额外空间的情况下在BST中找到继承者

4 个答案: