【问题标题】：Binary search tree Pointers issue二叉搜索树指针问题
【发布时间】：2020-03-18 22:10:47
【问题描述】：

我正在尝试实现一个应该在叶子中添加值的函数，这里是我的代码

节点结构：该节点包含两个 shild 左一个和右一个以及他的dadi（前身）和值。

struct arbre {
int val ;
struct arbre * D;
struct arbre * G ;
struct arbre * pere ;
};

这里是函数：该函数总是在叶子上添加值

void ajout_feuille( struct arbre** arbre , int value )
{
    struct arbre* q ,*p ;
    if ( *arbre == NULL)
    {
        q=malloc(sizeof(struct arbre ));
        q->D=NULL ;
        q->G=NULL;
        q->pere=NULL;
        q->val=value;
        *arbre=q ;
    }
    else
    {
    p=*arbre;
    while(p!=NULL)
    {
        if (p->val<value) //if the value is > we go on the right shild;
        {
            if (p->D==NULL) // if we are on the leaf 
            {
                q=malloc(sizeof(struct arbre ));
                q->val=value;
                q->D=NULL;
                q->G=NULL;
                q->pere=p;
                p->D=q;
            }else
            {
                p=p->D;
            }

        }else
        {
            if (p->val>value)
            {
                if(p->G==NULL)
                {
                     q=malloc(sizeof(struct arbre ));
                     q->val=value;
                     q->D=NULL;
                     q->G=NULL;
                     q->pere=p;
                     p->G=q;
                }
            }else { p=p->G; }
        }
    }
    }

}

这是显示方法：这是前缀显示方法

void affichage (struct arbre * arbre )
{
    if (arbre != NULL){
printf("%d\n",arbre->val);
    affichage(arbre->G);
    affichage(arbre->D);

}
}

这里是主要方法：

int main()
{
    struct arbre * A=NULL ;

    ajout_feuille(&A,5);
    ajout_feuille(&A,4);
    affichage(A);


    return 0;
}

问题是：显示方法没有显示任何内容我认为指针中有问题。

【问题讨论】：

你还没有真正问过问题，ajout_feuille 的代码不可读。
欢迎来到 StackOverflow。见minimal, reproducible example。在您发布 MRE 代码并准确说明问题之前，我们无法有效地帮助您。我们应该能够将您发布的代码粘贴到文本文件中并重现您指定的问题。由于您没有输出并且没有指定任何问题，因此这不是（尚）有效的 SO 问题。
显示功能不显示任何我认为 ajout_feuille 功能中的问题
树是一种递归数据结构。使用递归函数来处理它们比例如更容易。循环。
仅供参考，看在上帝的份上，记录该结构，或者最好仍然使用有意义的成员名称。还记得你的导师告诉你“让你的代码易于阅读，因为你不会一直是阅读它的人” 吗？嗯，就是这样。我们不应该解码您的代码。 left、right 和 parent 是很好的成员名称，并且会为阅读本文的任何人带来巨大清晰度。只是说。

标签： c algorithm pointers recursion binary-search-tree

【解决方案1】：

其中更多的指针和变量不会使代码更易于阅读。什么都不打印的原因是您的枚举循环永远不会终止。

您的代码有两个代码无限循环问题。请记住，此代码中没有 break 语句，因此释放 while 循环的唯一事情是 p 变为 NULL。

左侧结束遍历永远不会退出循环
重复的条目永远不会退出循环

关于第一个，Chasing a left-side traversal 永远不会将p 设置为 NULL，原因如下。考虑一下您的右侧遍历和左侧遍历之间的区别。

右侧遍历是这样做的：

        if (p->val<value) //if the value is >, we go on the right child;
        {
            if (p->D==NULL) // if we are on the leaf
            {
                q=malloc(sizeof(struct arbre ));
                q->val=value;
                q->D=NULL;
                q->G=NULL;
                q->pere=p;
                p->D=q;
            }
            else
            {
                p=p->D;
            }
        }

请特别注意 else-reaction p=p->D 所依赖的内容。现在看看你的左侧逻辑，它应该是相似的，但是使用反向逻辑追逐一个不同的指针（这是一个错误，最终在重复插入的情况下导致你的无限循环问题，但我们将在片刻）：

        if (p->val>value) // ok so far
        {
            if(p->G==NULL)
            {
                q=malloc(sizeof(struct arbre ));
                q->val=value;
                q->D=NULL;
                q->G=NULL;
                q->pere=p;
                p->G=q;
            }
        }
        else
        {
            p=p->G;
        }

注意 else 条件现在挂起的位置。首先，这是错误的，其次，除非您专门尝试构建 set （即没有重复的键），否则 if 和 else 真的不应该存在，如果那是在这种情况下，您仍然需要一个退出子句来打破原本无休止的while(p!=NULL) 状态。

以下是您的代码的完整功能版本，这些版本 (a) 不允许重复（您的目标似乎是），并且 (b) 允许重复。然后提供了一个替代方案，我强烈建议您查看。

修复 #1 - 无重复

void ajout_feuille0( struct arbre** arbre , int value )
{
    struct arbre* q ,*p ;
    if ( *arbre == NULL)
    {
        q=malloc(sizeof(struct arbre ));
        q->D=NULL ;
        q->G=NULL;
        q->pere=NULL;
        q->val=value;
        *arbre=q ;
    }
    else
    {
        p = *arbre;
        while (p!=NULL)
        {
            if (p->val<value) //if the value is > we go on the right shild;
            {
                if (p->D==NULL) // if we are on the leaf
                {
                    q=malloc(sizeof(struct arbre ));
                    q->val=value;
                    q->D=NULL;
                    q->G=NULL;
                    q->pere=p;
                    p->D=q;
                }
                else
                {
                    p=p->D;
                }
            }
            else if (value < p->val) // else if less we go down the left side.
            {
                if(p->G==NULL)
                {
                    q=malloc(sizeof(struct arbre ));
                    q->val=value;
                    q->D=NULL;
                    q->G=NULL;
                    q->pere=p;
                    p->G=q;
                }
                else
                {
                    p=p->G;
                }
            }
            else // else the value is already in the tree.
            {
                break;
            }
        }
    }
}

修复 #2 - 允许重复

void ajout_feuille0( struct arbre** arbre , int value )
{
    struct arbre* q ,*p ;
    if ( *arbre == NULL)
    {
        q=malloc(sizeof(struct arbre ));
        q->D=NULL ;
        q->G=NULL;
        q->pere=NULL;
        q->val=value;
        *arbre=q ;
    }
    else
    {
        p = *arbre;
        while (p!=NULL)
        {
            if (p->val<value) //if the value is > we go on the right shild;
            {
                if (p->D==NULL) // if we are on the leaf
                {
                    q=malloc(sizeof(struct arbre ));
                    q->val=value;
                    q->D=NULL;
                    q->G=NULL;
                    q->pere=p;
                    p->D=q;
                }
                else
                {
                    p=p->D;
                }
            }
            else
            {
                if(p->G==NULL)
                {
                    q=malloc(sizeof(struct arbre ));
                    q->val=value;
                    q->D=NULL;
                    q->G=NULL;
                    q->pere=p;
                    p->G=q;
                }
                else
                {
                    p=p->G;
                }
            }
        }
    }
}

另类

事实是，您不需要p 和q。你只需要两件事：

给你的指针指向指针。我们可以通过在下降过程中直接寻址每个指针来使用它来遍历树。
一个单背“父”指针，最初设置为 NULL，并在我们下降下一个子节点之前设置为当前节点指针。

使用这些，您可以更简洁地实现两种算法（无重复和允许重复）：

无重复

void ajout_feuille( struct arbre** tree , int value )
{
    struct arbre *pere = NULL;
    while (*tree)
    {
        pere = *tree;

        // left side ?
        if (value < (*tree)->val)
            tree = &(*tree)->G;

        // right side ?
        else if ((*tree)->val < value)
            tree = &(*tree)->D;

        else // duplicate found
            break;
    }

    if (!*tree) // null means we have a place to hang a node.
    {
        *tree = malloc(sizeof **tree);
        if (!*tree)
        {
            perror("Failed to allocate new tree node");
            exit(EXIT_FAILURE);
        }

        (*tree)->val = value;
        (*tree)->pere = pere;
        (*tree)->G = NULL;
        (*tree)->D = NULL;
    }
}

允许重复

void ajout_feuille( struct arbre** tree , int value )
{
    struct arbre *pere = NULL;
    while (*tree)
    {
        pere = *tree;

        // left side ?
        if (value < (*tree)->val)
            tree = &(*tree)->G;

        // els ejust move to right
        else tree = &(*tree)->D;
    }

    if (!*tree) // null means we have a place to hang a node.
    {
        *tree = malloc(sizeof **tree);
        if (!*tree)
        {
            perror("Failed to allocate new tree node");
            exit(EXIT_FAILURE);
        }

        (*tree)->val = value;
        (*tree)->pere = pere;
        (*tree)->G = NULL;
        (*tree)->D = NULL;
    }
}

在这两种情况下，代码都更加简洁，并且避免了通过外部 while 的额外循环。

希望对你有帮助。

【讨论】：