BST 中的这个递归函数如何返回一个有序的链表？

Question

BST中的这个递归函数如何返回一个有序的链表？

给定：（结构）

typedef struct TreeNode
{
    struct TreeNode *left ;  //left child
    struct TreeNode *right ;     //right child
    struct TreeNode *next ;  //field for linked list in tree
    Data Node_info;             //info data in node
} TreeNode;

假设我们有一个数字为 3、2、4 的 BST。 （3 是根，2 是左孩子，4 是右孩子）

我有 2 个功能相同，它们从 BST 创建一个链表。我这里没能跟进递归，如果有人能帮我弄清楚，那就太棒了！

第一个函数：

void  what1(TreeNode **head, TreeNode *root)
{
     if(root == NULL) 
           return; 
     what1((head),root->right);
     root->next=(*head);
     (*head)=root;
     what1((head),root->left);
}

我的计算： 走到右子树，直到我们到达 null，返回，做 4->在 NULL 上的下一个点，在 4 上做头点，然后向左，返回到 4，返回再次到 1，现在 3->在 4 上的下一个点，然后在 4 上做头点，依此类推..

但是我仍然不了解其他函数何时“暂停”以及它们何时执行，这意味着我的计算不准确并且我无法正确跟进该函数，这意味着我在某些地方缺乏对递归的理解.

这是我完全不知道如何遵循它的第二个函数，它实际上做同样的事情。如果您可以帮助我使用这些功能中的任何一个，我将不胜感激，因为我正在尝试完全理解 BST 的递归。在我完全理解这一点之前，我会在这里发布很多关于此的问题。

TreeNode * what2(TreeNode *root)
{
    TreeNode *left = NULL, *right = NULL, *tmp = root;
    if (root != NULL) 
    {      
        left = what2(root->left);      
        right = what2(root->right);      
        root->next = right;      
        if (left != NULL)
        {
            tmp=left;  
            while (left->next != NULL)              
                left=left->next;         
            left->next=root;      
        }   
    } 
    return tmp;
}   

Answer 1

第一个函数的工作原理是对的，基本上是从头到尾构建树。

要理解第二个，你需要注意的是它会在子树中创建一个列表，然后将两个列表组合起来。当您调用该函数时，会发生以下步骤：

1. 获取仅从左侧节点创建的列表的头部
2. 获取仅从右侧节点创建的列表的头部
3. 通过将左链表的末尾设置为指向根节点来附加根节点，然后让根节点指向右链表的开头。

可以看到

1.

left = what2(root->left);

在您的示例中，这将简单地返回左侧节点，因为它是单独的，但是发生这种情况是因为左侧节点的 left->left 和 left->right 为 NULL，所以它只返回 left。

2.

right = what2(root->right);

这里发生了同样的事情，但使用了正确的节点。

3.

root->next = right;      
if (left != NULL)
{
    tmp=left;  
    while (left->next != NULL)              
        left=left->next;         
    left->next=root;      
} 

在这里，我们首先将root->next 设置为right，这样我们就基本上创建了列表的中间部分。然后，将tmp 设置为left，因为它将成为列表的头部（最左边，所以开始）。然后遍历左侧列表，直到我们可以将最后一个元素设置为root。这会创建一个从left 到root 到right 的连续列表，因此是有序的。

Answer 2

这是给what1的。

这里，head 是 Node ** - 这意味着：

head   : is a : pointer to a pointer to TreeNode
*head  : is a : pointer to a TreeNode
**head : is a : TreeNode

现在，当 what1 从 main（或其他一些函数）调用它时，它的调用方式如下：

/* Suppose root points to root TreeNode in tree */

/* ll_head will point to first node in linked list */
TreeNode *ll_head = NULL;

/* Call what1 and pass address of ll_head so that
 * address of the first node in linked_list can be stored in ll_head
 */  
what1(&ll_head, root);

现在看看当what1(&llhead, root)（即what1(&ll_head, node 3)）被调用时会发生什么：

当what1(&ll_head, node 3) 被调用时，它会执行以下操作：

1. 调用（&ll_head，节点 4）
2. 对节点 3 进行一些处理
3. 调用（&ll_head，节点 2）

让我们一一看看：

1.在节点 4

4->next = (*head) /* which right now is pointing to NULL */ 
(*head) /* which is ll_head in main */ = address of node 4 

所以，到现在为止：

4->next = NULL, and 
(*head) /* which is ll_head in main */ =  address of node 4

2。在节点 3 中处理

3->next = (*head) /* which right now is pointing to node 4 */
(*head) /* which is ll_head in main */ = address of node 3

所以，到现在为止：

4->next is NULL,
3->next = address of node 4, and
(*head) /* which is ll_head in main */  = address of node 3

3.在节点 2

2->next = (*head) /* which right now is pointing to node 3 */
3->next = address of node 4
4->next = NULL, and
(*head) /* which is ll_head in main */  = address of node 2

所以当 what1(*ll_head, node3) 返回时，这将是事物的状态：

ll_head = address of node 2
2->next = address of node 3
3->next = address of node 4
4->next = NULL

哪个是这个 BST 的有序链表。