Listes chaînées simples dans C

Question

J'essaie fondamentalement de créer une liste chaînée à partir d'un fichier texte et d'ajouter un nouveau membre chaque fois que les mots sont différents, et d'incrémenter le compte si les mots sont identiques (affectation hw). Je pensais que je l'ai fait correctement, mais il semble ajouter un membre, peu importe quoi. Je me demande si je traverse la liste incorrectement pendant que je recherche? Voici mon code. Des pensées? Merci!

LIST *CreateList(FILE *fp) 
{ 
    char input[LINE_LEN]; 
    LIST *root= NULL;    /* contains root of list    */ 
    size_t strSize;  
    LIST *newList;   /* used to allocate new list members */ 
    int same;    /* if string is same */ 

    while (fscanf(fp, BUFFMT"s", input) != EOF) { 

     strSize = strlen(input) + 1; 

      if (root == NULL) { 
       if ((newList = (LIST *)malloc(sizeof(LIST))) == NULL) { 
        printf("Out of memory..."); 
        exit(EXIT_FAILURE); 
       } 
       if ((newList->str = (char *)malloc(sizeof(strSize))) == NULL) { 
        printf("Not enough memory for %s", input); 
        exit(EXIT_FAILURE); 
       } 
       memcpy(newList->str, input, strSize); /*copy string */ 
       newList->count = START_COUNT; 
       newList->next = NULL; 
       root = newList; 
      } 
      /* if not root node, add node, or increment count */ 
      else { 
       same = ListSame(newList, input); 
       if (same == 1) { 
        root->count++; 
       } 
       else { 
        if ((newList = (LIST *)malloc(sizeof(LIST))) == NULL) { 
         printf("Out of memory..."); 
         exit(EXIT_FAILURE); 
        } 
        if ((newList->str = (char *)malloc(sizeof(strSize))) == NULL) { 
         printf("Not enough memory for %s", input); 
         exit(EXIT_FAILURE); 
        } 
        memcpy(newList->str, input, strSize); /*copy string */ 
        newList->count = START_COUNT; 
        newList->next = root->next; 
        root->next = newList; 
       } 
      } 
    } 
     return root; 
} 

int ListSame(LIST *head, char *input) 
{ 
    LIST *start = head; 
    for (; start != NULL; start = start->next) { 
     if (strcmp(head->str, input) == 0) { 
      return 1; 
     } 
    } 
    return 0; 
} 

Answer 1

Vous appelez ListSame avec newList, qui sera toujours seulement le dernier nœud créé. Il semble que vous vouliez passer la racine à ListSame. De plus, dans ListSame, il vérifie toujours head-> str, pas start-> str, qui est votre variable de bouclage.

De même, si ListSame renvoie true (1), vous incrémentez root-> count; Je ne suis pas sûr si vous voulez incrémenter le compte du noeud racine (compter le nombre total de doublons) ou le compte du noeud qui a le doublon (compte combien de fois chaque mot apparaît). Si c'est le dernier, ListSame va devoir retourner quel noeud est le doublon, ou il va devoir incrémenter le compte lui-même.

En outre, la façon dont vous construisez la liste est un peu déroutante. Quand vous dites:

newList->next = root->next; 
root->next = newList;

root-> suivant avant que cela ne soit NULL, ou le dernier nœud créé. Donc, quand vous faites l'insertion ici, vous l'insérez toujours comme le deuxième élément de la liste. Ce n'est probablement pas ce que vous voulez. Si vous voulez ajouter, vous devez garder une trace de la queue ainsi que de la tête; si vous voulez préfixer, vient de mettre newList->next = root; root = newList;

Answer 2

LIST *start = head; 
for (; start != NULL; start = start->next) { 
    if (strcmp(head->str, input) == 0) { 
     return 1; 
    } 
} 

si vous utilisez

strcmp(start->str