二叉搜索树插入如何使用递归进行？

Question

我在理解二叉搜索树插入的递归部分时遇到了一些麻烦。

bstnode* insert(bstnode* root,int data)
{
    if(root==NULL){
        bstnode* tmp= new bstnode();
        tmp->data=data;
        tmp->left=tmp->right=NULL;
        return tmp;
    }

    if(data<root->data)     
        root->left = insert(root->left, data); 
    else 
        root->right = insert(root->right, data); //can't understand the logic here
    return root; 
}

/* consider following BST with their addresses[]:
              15 [100]
             /  \
           10    20 [200]
                   \
                   tmp [300]  
*/

据我所知root->right = insert(root->right, data); 应该将新创建的节点的地址存储在root->right 中，因此此代码不适用于高度>2 的树。
但是，它适用于任意数量的节点。
我必须在这里遗漏一些重要的细节。

假设我想在 BST 中插入 25，即 insert(root,25);
如 25>15：-

我在这里分解递归部分：
root->right = insert(root->right, 25);
或 15->right = insert(15->right,25); 在这里，再次递归调用它，因为 25>20
insert(root->right, 25) => root->right->right = insert(root->right->right, 25);
或 insert(15->right, 25) => 20->right = insert(20->right, 25);

insert(20->right,25) 是 NULL，因此创建了一个新节点 tmp。
insert(20->right,25); 返回 tmp。

现在展开递归。

//20->right = insert(20->right, 25);

所以，

20->right=300（tmp地址）；

//insert(15->right, 25) => 20->right
//and 15->right = insert(15->right,25);

15->right = 20->next;
因此15->right = [300] 地址。
要么 root->right = [300] 地址。
我的方法有什么问题？

再次概述递归调用：

15->right = insert(15->right,25);
15->right = [20->right = insert(20->right,25)]; //20->right is NULL so creating new node
15->right = [20->right=   300 address of tmp];
15->right = [20->right or 300]
15->right = [300] // but in reality 15->right = [200]

Answer 1

您忘记了 root->right 是您作为 root 传递给函数的地址的 root->right。每个对 insert 的调用都会传入 root->right 或 root->left ，具体取决于您遍历的方式。

此说法不正确：

root->right = root->right->right = tmp;

一旦函数的迭代被返回，它就会从堆栈中删除，所以在这种情况下，我们有 3 次调用，我将用你的数字代替指针值。

insert(15->right,25)
insert(20->right,25) 

最后一个是空的，所以它使用 25 创建节点并将其返回到调用 insert(20->right,25) 并将 25 设置为 20->right 所以你有一个看起来像这样的树

/* consider following BST with their addresses[]:

              20 [200]
               \
                25 [300]  
*/

然后它将这棵树返回到调用 insert(15->right,25) 并将该树设置为我们刚刚返回的树，这样我们就得到了最终的树

/* consider following BST with their addresses[]:
          15 [100]
         /  \
       30    20 [200]
               \
                25 [300]  
*/

编辑：让我看看我是否可以澄清。让我们再看看你的树

/* consider following BST with their addresses[]:
          15 [100]
         /  \
       10    20 [200]
               \
               tmp [300]  
*/

我们想要插入 25，所以我们调用（我将再次使用树的那个节点处的值来表示我们正在传递的指针） 插入(15, 25)

然后在 root->right 上调用 insert，恰好是 20

insert(20, 25)

这会在右边的 20 个节点上再次调用 insert，这恰好是 null

insert(null,25)

现在让我们看看回报

insert(null,25) 返回一个包含 25 的节点，然后从堆栈中移除

 return 25;

insert(20,25) 返回一个 25 的节点。它将其右子节点设置为 25，如下所示

 20->right = 25;
 return 20;

现在我们回到原来的 insert(15,25) 调用。它返回了 20。所以它确实

15->right = 20;
return 15; 

Answer 2

我认为您的困惑可能来自两个不同的来源。 首先，在您的代码中注释的树是不可能的。其次，只有在函数传入空指针时才会创建新节点。只有小于 15 的值才能向左移动。它会是这样的（取决于添加顺序）：

   15
  /  \
     20
    /  \
       30

当你把 25 加到这个上时，结果如下：

   15
  /  \
     20
    /  \
        30
       /
      25

我将尝试逐步通过代码进行解释。在第一个函数调用上将 25 添加到原始树时，第一个节点不是 NULL 并且 25 > 15 所以

else
{ 
    root->right = insert(root->right, data);
}

被调用。这会递归调用相同的插入函数，但现在使用 20 节点作为比较。再次不是 null 并且 25 > 20 所以在右节点上调用 insert 如上所述。这再次调用递归函数，但现在在 30. 25

Answer 3

在某种程度上你是对的。您永远不能拥有高度 > 2 的子树（不是树）。

在这段代码中，您永远不会有root->right->right，因为就代码而言，当您调用 root->left = insert(root->left, data);

（本地）根指针现在指向您刚刚插入的节点。 （本地）根指向root->left.

因此，您可以拥有任意高度的树（但是，本地根指针指向高度

Answer 4

注意insert() 总是返回作为参数传递给它的root，除非root == NULL。因此，您插入的新节点无法“向上走”。递归调用中发生的事情无关紧要——您总是返回与在非NULL 情况下传递的相同的root。

尽管有些人教递归的方式，我认为它有助于（无论如何对我的大脑）不尝试展开递归，而是考虑逻辑是否有意义：

如果您传递了一个非NULL 节点和data < root->data，如果您执行root->left = insert(root->left, data) 并假设insert() 神奇地“正常工作”（即它插入@987654330），您会得到正确的结果吗？ @ 进入左树并返回该树的根）？

如果逻辑检查了左右情况，则考虑基本情况：如果传递了NULL 节点，你会返回正确的单元素树吗？

如果逻辑也检查了基本情况，那么您知道您的代码必须是正确的，因为递归步骤是有意义的，并且您知道您将进入一个也有意义的基本情况（因为您最终会达到一个NULL 节点，当你沿着树走时）。