二叉树未从文件中添加字符串 #包括 #包括 树状结构 { 字符*字； 整数； 结构树节点*rightPTR，*leftPTR； }; 类型定义结构树节点； node*rootPTR=NULL； void freeTree（节点*currPTR） { 如果（currPTR！=NULL） { freeTree（currPTR->leftPTR）； 免费（currPTR）； freeTree（currPTR->rightPTR）； } } 无效打印树（节点*currPTR） { 如果（currPTR！=NULL） { 打印树（currPTR->leftPTR）； printf（“%s出现了：%d次\n”，currPTR->word，currPTR->NumberCnt）； 打印树（currPTR->rightPTR）； } } int insertNode（字符*输入） { node*temptr=malloc（sizeof（node））； temptr->word=输入； temptr->NumberCnt=0； temptr->leftPTR=NULL； temptr->rightpr=NULL； if（rootPTR==NULL） { rootPTR=temptr； rootPTR->NumberCnt++； } 其他的 { 节点*currPTR=rootPTR； node*prevPTR=NULL； while（currPTR！=NULL） { int comp=strcmp（输入，（currPTR->word））； 如果（comp==0） { printf（“条目已存在\n”）； currPTR->NumberCnt++； 返回1； } 否则如果（组件leftPTR； } 否则如果（补偿>0） { prevPTR=currPTR； currPTR=currPTR->rightPTR； } } int comp=strcmp（输入，（prevPTR->word））； if（compleftPTR=tempPTR； prevPTR->NumberCnt++； } 否则如果（补偿>0） { prevPTR->rightPTR=tempPTR； prevPTR->NumberCnt++； } 返回0； } printf（“root1%s\n”，rootPTR->word）； 返回2； } 整数搜索（字符*输入） { 如果（输入==rootPTR->word） { printf（“节点找到%s\n”，rootPTR->word）； 返回0； } 其他的 { 如果（输入word） { 节点*currPTR=rootPTR->leftPTR； while（currPTR！=NULL） { 如果（输入==currPTR->word） { printf（“节点找到%s\n”，currPTR->word）； 返回0； } else if（输入word） { currPTR=（currPTR->leftPTR）； } else if（输入>电流>文字） { currPTR=（currPTR->rightPTR）； } } printf（“节点不在树中\n”）； 返回1； } 如果（输入>根PTR->word） { 节点*currPTR=rootPTR->rightPTR； while（currPTR！=NULL） { 如果（输入==currPTR->word） { printf（“节点找到%s\n”，currPTR->word）； 返回0； } else if（输入word） { currPTR=（currPTR->leftPTR）； } else if（输入>电流>文字） { currPTR=（currPTR->rightPTR）； } } printf（“节点不在树中\n”）； 返回1； } } 返回2； } 无效固定字（字符*浅黄色） { char*unfixed=buff； 字符*固定=浅黄色； while（*未固定） { 如果（isalpha（*未固定）） { *固定=tolower（*未固定）； *固定++； } *不固定++； } *固定=0； } int main（） { 文件*ptr_文件； 字符buff[100]； //ptr_file=fopen（“sherlock.txt”，“r”）； ptr_file=fopen（“input.txt”，“r”）； 如果（！ptr_文件） printf（“文件读取错误”）； while（fscanf（ptr_文件，“%s”，buff）！=EOF） { int比较=strcmp（buff，“endofile”）； 如果（比较==0） { 返回0； } 固定词（buff）； 插入节点（buff）； } fclose（ptr_文件）； printf（“根：%s\n”，rootPTR->word）； 返回0； }

好的，我有一个二叉树，它从一个文件中获取字符串输入。如果我直接将字符串传递给树，它就会工作，但是当我试图传递从文件中读取的字符串时，它会不断替换根节点，并且不会将它们正确地添加到树中

将

buff

传递给insert函数，并将其存储在节点中。因此，所有节点都将指向相同的地址，即main中的

buff

您需要为每个节点中的每个字符串分配存储空间，并将输入复制到该节点中。当你删除你的树时，记得正确地解除分配

---

strdup

如果您的库中有，则可以很方便地进行此操作。

buff是当前行值，并在每行读取时覆盖：

#include <stdio.h>
#include <stdlib.h>

struct treeNode
{
    char *word;
    int NumberCnt; 
    struct treeNode *rightPTR, *leftPTR; 

};
typedef struct treeNode node;

node *rootPTR = NULL;

void freeTree(node *currPTR)
{
    if (currPTR!= NULL)
   {
        freeTree(currPTR -> leftPTR);
        free(currPTR);
        freeTree(currPTR -> rightPTR);
   }
}

void printTree(node *currPTR)
{
    if (currPTR != NULL)
        {
            printTree(currPTR ->leftPTR);   
            printf("%s appeared:%d times\n", currPTR->word, currPTR->NumberCnt);
            printTree(currPTR ->rightPTR);  
        }
}



int insertNode (char* input)
{

    node *tempPTR = malloc(sizeof(node));
    tempPTR -> word = input;
    tempPTR -> NumberCnt=0;
    tempPTR -> leftPTR = NULL;
    tempPTR -> rightPTR = NULL;

    if (rootPTR == NULL)
    {   
        rootPTR = tempPTR;
        rootPTR -> NumberCnt++;
    }

    else 
    {

        node *currPTR = rootPTR;
        node *prevPTR = NULL;

            while (currPTR != NULL)
            {

             int comp = strcmp(input, (currPTR->word));  
                if (comp == 0)
                {
                    printf ("Entry already exists\n");
                    currPTR->NumberCnt++;
                    return 1;   
                }
                else if (comp < 0)
                {
                    prevPTR = currPTR;
                    currPTR = currPTR->leftPTR;
                }
                else if (comp > 0)
                {

                    prevPTR = currPTR;
                    currPTR = currPTR->rightPTR;
                }

            }

        int comp = strcmp(input, (prevPTR ->word));
        if (comp < 0)
        {
             prevPTR->leftPTR = tempPTR;
             prevPTR ->NumberCnt++;

        }

        else if (comp > 0)
        {
            prevPTR->rightPTR = tempPTR;
            prevPTR->NumberCnt++;

        }

         return 0;  
    }
     printf("root1%s\n",rootPTR->word);

    return 2;
 }

 int search(char* input) 
{
     if (input == rootPTR ->word)
    {
        printf("Node found %s\n", rootPTR->word);
        return 0;
    }
    else
    {
        if (input < rootPTR ->word)
            {

                node *currPTR = rootPTR->leftPTR;

                while (currPTR != NULL)
                {
                    if (input == currPTR->word)
                    {
                        printf("Node found %s\n", currPTR->word);
                        return 0;
                    }
                    else if (input < currPTR->word)
                    {
                    currPTR = (currPTR -> leftPTR); 
                    }
                    else if (input > currPTR->word)
                    {
                        currPTR = (currPTR -> rightPTR);
                    } 
                 }
                printf ("Node not in tree\n");
                return 1;
            }

            if (input > rootPTR ->word)
            {

                node *currPTR = rootPTR->rightPTR;

                while (currPTR != NULL)
                {

                    if (input == currPTR->word)
                    {
                        printf ("Node found %s\n", currPTR->word);
                        return 0;
                    }

                    else if (input < currPTR->word)
                    {
                        currPTR = (currPTR -> leftPTR); 
                    }

                    else if (input > currPTR->word)
                    {
                        currPTR = (currPTR ->rightPTR);
                    }
                }
                 printf ("Node not in tree\n");
                return 1;
            }

    } 

 return 2;
 }

 void fixWord(char* buff)
{
    char* unfixed = buff;
    char* fixed = buff;

     while (*unfixed)
     {

             if (isalpha(*unfixed))
        {
            *fixed=tolower(*unfixed);
            *fixed++;

        }   
            *unfixed++;


    }
    *fixed=0;

}


int main()
{   
FILE *ptr_file;
char buff [100];
//ptr_file = fopen ("sherlock.txt", "r");
ptr_file = fopen ("input.txt", "r");
if (!ptr_file)
    printf("File read error");


    while(fscanf(ptr_file, "%s ", buff ) != EOF)
    {
        int comparison = strcmp(buff, "endoffile");
        if (comparison == 0)
        {
            return 0;
        }

         fixWord(buff);
         insertNode(buff);

    }


fclose(ptr_file);
printf("root:%s\n", rootPTR->word);


return 0;
 }

insertNode分配覆盖的缓冲区

insertNode(buff);

因此，您应该动态分配输入值，如下所示：

int insertNode (char* input)
{
    node *tempPTR = malloc(sizeof(node));
    tempPTR -> word = input;
    ....

---

嗯,但是buff不应该每次都不一样吗?？当它循环时，一组字符被添加到其中。不，buff是主循环中的一个局部变量。只有一个，它的地址是固定的，直到主出口（此时它也不再存在）。

int insertNode (char* input)
{
    node *tempPTR = malloc(sizeof(node));
    tempPTR -> word = strdup(input);
    ....