了解从二进制搜索树中删除节点时的递归调用

Question

使用给定密钥在BST中删除节点的功能如下：

struct node* deleteNode(struct node* root, int key)
{
    // base case
    if (root == NULL) return root;

    // If the key to be deleted is smaller than the root's key,
    // then it lies in left subtree
    if (key < root->key)
        root->left = deleteNode(root->left, key);

    // If the key to be deleted is greater than the root's key,
    // then it lies in right subtree
    else if (key > root->key)
        root->right = deleteNode(root->right, key);

    // if key is same as root's key, then This is the node
    // to be deleted
    else
    {
        // node with only one child or no child
        if (root->left == NULL)
        {
            struct node *temp = root->right;
            free(root);
            return temp;
        }
        else if (root->right == NULL)
        {
            struct node *temp = root->left;
            free(root);
            return temp;
        }

        // node with two children: Get the inorder successor (smallest
        // in the right subtree)
        struct node* temp = minValueNode(root->right);

        // Copy the inorder successor's content to this node
        root->key = temp->key;

        // Delete the inorder successor
        root->right = deleteNode(root->right, temp->key);
    }
    return root;
}

将具有遍历遍历的树视为：50 30 20 40 70 60 80

我希望删除节点20。函数调用如下：

deleteNode(root=50, 20) 
deleteNode(root=30, 20)
deleteNode(root=20, 20)

当到达此调用（deleteNode（20，20））时，将执行else部分。 由于root->left == NULL ，因此被截断的代码执行为：

temp = root->right (which is NULL)
free (root)
return temp (returning NULL)

它返回到最后一次调用root->left = deleteNode(20, 20) = NULL 。 其他调用（即deleteNode(30, 20) and deleteNode(50, 20) ）发生了什么，在执行结束时将返回根。 实际返回了哪些根？

Answer 1

要回答“实际上返回了哪一个根”……它们都是。 问题是它们返回到哪里以及最终值是多少。

当您遍历代码时，您会看到在哪里执行了递归函数调用，并了解到您使用不同的值创建了该函数的新副本，并再次从顶部开始跟踪。 您现在正在取消该过程。

从您中断的地方开始， return temp值return temp为NULL到您意识到的root->left = deletenode(20, 20)的函数调用中。 现在，您从该点恢复执行。 else if无法神奇地重新评估else if和else条件，您将return root其左节点设置为NULL的根。 然后将此根返回到deletenode(30,20)然后将左或右部分替换为返回的值。

这种模式会一直持续到所有函数调用都解决为止。 名称root可能会造成混淆，但是它是递归过程中创建的每个子树的“根”，它们仅形成原始树的分支。

为了提供一些例证，请使用您的值：

       50             <- root for deletenode("node 50", x)
     /    \
   30      70         <- root for deletenode("node 50"-> left or right, x)
  /  \    /  \
20   40 60    80      <- root for deletenote("node 50"->left/right->left/right,x)

尝试为您追踪：

• deleteNode（“节点50”，20）
• 如果（root == NULL）为false，则跳过语句（让我们将root称为“节点50”）
• 如果（20 <50）为true，则执行“ node 50”-> left = deleteNode（“ node 50”-> left，20）
  • 如果（root == NULL）为false，则跳过语句（root现在为“ node 50”-> left或“ node 30”）
  • 如果（20 <30）为true，则执行“ node 30”-> left = deleteNode（“ node 30”-> left，20）
    • 如果（root == NULL）为false，则跳过语句（root为“节点20”）
    • 如果（20 <20）为假，则跳过块
    • 否则（20> 20）为假，则跳过
    • 否则阻止：
      • 如果（“节点20”-> left == NULL）为true
      • 用“子节点20”的右子节点创建一个临时节点（可能为NULL）
      • 删除“节点20”
      • 返回临时节点的地址
  • 将返回值（NULL）分配给“节点30”-> left
  • 控制流绕过其余的if结构，执行返回“节点30”
• 返回“节点30”，将值分配给“节点50”->左
• 控制流绕过其余的if结构，执行返回“节点50”

跟踪结束。

您返回的树现在看起来像：

         50             <- root for deletenode("node 50", x)
       /    \
     30      70         <- root for deletenode("node 50"-> left or right, x)
    /  \    /  \
NULL    40 60    80      <- root for deletenote("node 50"->left/right->left/right,x)

Answer 2

我认为理解递归函数的“窍门”是先了解非递归函数，然后再认识到递归函数的工作原理完全相同 。

想象一下，对于树的每个级别都有一个功能deleteNode_1 ， deleteNode_2 ， deleteNode_3等等。

您将通过将树的根传递给deleteNode_1来进行第一个调用。

如果要删除的节点在其参数的子树中， deleteNode_1 deleteNode_2用该子树调用deleteNode_2 ，并用结果替换其参数的子树之一。

对deleteNode_2的调用可能会调用deleteNode_3 ，依此类推，但是deleteNode_1不需要关心这一点，它只关心从deleteNode_2返回合适的子树。

他们看起来像这样：

// Delete a node when 'current' is at level 1
struct node* deleteNode_1(struct node* current, int key);
// Delete a node when 'current' is at level 2
struct node* deleteNode_2(struct node* current, int key);
// Delete a node when 'current' is at level 3
struct node* deleteNode_3(struct node* current, int key);

// .. and so on, as many as you need.

并像这样实现：

struct node* deleteNode_1(struct node* current, int key)
{
    if (current == NULL) return current;
    if (key < current->key)
        current->left = deleteNode_2(current->left, key);
    else if (key > current->key)
        current->right = deleteNode_2(current->right, key);
    else
    {
        if (current->left == NULL)
        {
            struct node *temp = current->right;
            free(current);
            return temp;
        }
        else if (current->right == NULL)
        {
            struct node *temp = current->left;
            free(current);
            return temp;
        }

        struct node* temp = minValueNode(current->right);
        current->key = temp->key;
        current->right = deleteNode_2(current->right, temp->key);
    }
    return current;
}


struct node* deleteNode_2(struct node* current, int key)
{
    if (current == NULL) return current;
    if (key < current->key)
        current->left = deleteNode_3(current->left, key);
    else if (key > current->key)
        current->right = deleteNode_3(current->right, key);
    else
    {
        if (current->left == NULL)
        {
            struct node *temp = current->right;
            free(current);
            return temp;
        }
        else if (current->right == NULL)
        {
            struct node *temp = current->left;
            free(current);
            return temp;
        }

        struct node* temp = minValueNode(current->right);
        current->key = temp->key;
        current->right = deleteNode_3(current->right, temp->key);
    }
    return current;
}

// ...

如果您了解这些功能的工作原理，那么了解递归功能的步骤就非常小。