1
votes

correction pour un lien inversé

hé pour une raison quelconque, ma liste chaînée s'imprime dans l'ordre inversé, par exemple si mon entrée est 2-> 4-> 6 ma sortie est 6-> 4-> 2

list* add_int_list(list* a,int b)
{
    list *temp;
    temp = (list*)malloc(sizeof(list*));
    temp->next = NULL;
    if (a->next == NULL)//insert to the first node
    {
        temp->data = b;
        temp->next = a;
        a = temp;

    }
    else 
    {
        temp->data = b;
        temp->next = a;
        a = temp;//I think the problem is here, couldnt find how to fix 
}

c linked-list insert singly-linked-list

6 commentaires

Hé! Pour une raison quelconque, votre code pour insérer le premier nœud et les suivants est le même. Cela signifie que vous insérez toujours de nouveaux nœuds à l'avant, ce qui créera une liste dans l'ordre d'insertion inversé. (Ce n'est pas non plus tout le code que vous affichez. Vous renvoyez sûrement la nouvelle tête de liste, non?)

Si vous souhaitez ajouter quelque chose à la fin de la liste, vous devez parcourir la liste, puis l'ajouter en tant que dernier nœud. (Parcourez les pointeurs -> suivant jusqu'à NULL. Et puis insérez le nœud temp à la fin de la liste.)

Quel est le but de l'instruction if ? Les deux branches ont un code identique . Faites-les différents ou supprimez le if .

De plus, je crois que votre code plantera si vous passez NULL pour a . Vous devez gérer ce cas avant d'essayer de le déréférencer avec l'instruction de flèche à la ligne 6.

et puis-je faire cela dans la même fonction ajouter à la tête et à la fin?

Cela dépend de l'objectif de votre fonction. Vous pouvez l'écrire pour faire ce que vous voulez. Mais à en juger par votre sortie attendue, il semble que vous vouliez toujours ajouter à la fin de la liste. Dans ce cas, l'ajout à la tête n'est pas vraiment nécessaire, sauf si l'entrée est NULL . Je mets une réponse qui peut vous guider dans la bonne direction.

3 Réponses :

2
votes

Le problème est que votre code ajoute le nœud au début de la liste dans les deux cas. Si vous voulez toujours ajouter à la fin de la liste, vous devez parcourir la liste jusqu'à la fin, puis y ajouter temp .

J'ai écrit ce code spontanément, alors prenez comme pseudo-code:

// Assuming this function returns the front (head) of the list.
list* append_element_to_list(list* a, int b)
{
    list *newNode;
    newNode = (list*)malloc(sizeof(list*));
    newNode->data = b;

    // Handle the case where `a` is NULL. This means
    // no list was passed in, so the newly created node
    // will be returned to start the list.
    if (a == NULL)
    {
      return newNode;
    }

    // If we get this far, it means `a` contains at least
    // one node. So walk the list until the end.
    list *currentNode = a;
    while (currentNode->next != NULL)
    {
      currentNode = currentNode->next;
    }

    // Once you reach the end of the list, set
    // `newNode` as the last node.
    currentNode->next = newNode;

    // The front of the list hasn't changed, so return that.
    return a;
}

0 commentaires

2
votes

Vous avez des erreurs dans votre code, je fais des corrections dans votre code, je ne fais que changer ce qui est requis. Je veux d'abord me concentrer sur le problème principal, avant d'insérer enfin une liste, vous devez parcourir la liste complète.

#include <stdio.h>
#include <malloc.h>
typedef struct node{
 int data;
 struct node *next;

}list;

list* add_int_list(list* a,int b)
{
    list *temp;
    list *i;

    temp = (list*)malloc(sizeof(list*));
    temp->next = NULL;
    temp->data = b;

    if (a == NULL)//insert to the first node
    {
       //temp->data = b; -  done above
    //temp->next = a; no reason for this line
        a = temp;
    }
    else
    {
       // temp->data = b; - done above
       //temp->next = a; wrong logic
       // a = temp;//I think the problem is here, couldnt find how to fix : Yes it is also wrong

      //Here it required to iterate complete list and go to end

      i = a; // to iterate
      while(i->next != NULL)
      {
       i = i->next;
      }
      // Now i is last node of list a
      i->next = temp;
    }

    return a;
}
void printList(list *root)
{
   list *i;

   if(root == NULL)
   {
    printf("List is empty");
   }
   else
   {
    i = root;
    while(i != NULL){
      printf("%d,",i->data);
      i = i->next;
    }
   }
}
int main()
{
  list *root = NULL;
  clrscr();
  root =  add_int_list(root, 3);
  root =  add_int_list(root, 4);
  root =  add_int_list(root, 5);
  printList(root);
    return 0;
}

Maintenant, le code ci-dessous, je le vérifie simplement sur TurboC, j'utilise votre fonction et en insérant trois valeurs puis en imprimant la liste. S'il vous plaît voir tous les commentaires de ligne:

  i = a; // to iterate
  while(i->next != NULL)
  {
   i = i->next;
  }
  // Now i is last node of list a
  i->next = temp;

3 commentaires

Je pense qu'il y a quelques erreurs dans printList . La ligne if (root-> data == NULL) vérifie un int par rapport à NULL . Devrait probablement être if (root == NULL) . Toujours dans la même méthode, la ligne while (i-> data! = NULL) { fait la même erreur. Devrait probablement être while (i-> next! = NULL) {. Enfin, l'impression de la liste ne semble pas imprimer la valeur finale. Vous aurez peut-être besoin d'un dernier printf ("% d \ n", i-> data); après la boucle while.

void printList (liste * racine) {liste * i; if (! root) {printf ("La liste est vide"); } else {i = racine; while (i) {printf ("% d,", i-> données); i = i-> suivant; }}}

@MrHappyAsthma, merci pour votre suggestion, je l'ai édité.

3
votes

Pour commencer, dans cette instruction

List list = { NULL, NULL };

, il y a de la mémoire allouée d'une taille égale à la taille du pointeur au lieu de la taille du nœud. Vous devez écrire soit

List list = { .head = NULL, .tail = NULL };

0 -> null
1 -> 0 -> null
1 -> 0 -> 2 -> null
3 -> 1 -> 0 -> 2 -> null
3 -> 1 -> 0 -> 2 -> 4 -> null
5 -> 3 -> 1 -> 0 -> 2 -> 4 -> null
5 -> 3 -> 1 -> 0 -> 2 -> 4 -> 6 -> null
7 -> 5 -> 3 -> 1 -> 0 -> 2 -> 4 -> 6 -> null
7 -> 5 -> 3 -> 1 -> 0 -> 2 -> 4 -> 6 -> 8 -> null
9 -> 7 -> 5 -> 3 -> 1 -> 0 -> 2 -> 4 -> 6 -> 8 -> null

This if statement

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

typedef struct Node
{
    int data;
    struct Node *next;
} Node;

typedef struct List
{
    Node *head;
    Node *tail;
} List;

int push_front( List *list, int data )
{
    Node *new_node = malloc( sizeof( Node ) );
    int success = new_node != NULL;

    if ( success )
    {
        new_node->data = data;
        new_node->next = list->head;

        list->head = new_node;

        if ( list->tail == NULL ) list->tail = list->head;
    }

    return success;
}

int push_back( List *list, int data )
{
    Node *new_node = malloc( sizeof( Node ) );
    int success = new_node != NULL;

    if ( success )
    {
        new_node->data = data;
        new_node->next = NULL;

        if ( list->tail == NULL )
        {
            list->head = list->tail = new_node;
        }
        else
        {
            list->tail = list->tail->next = new_node;
        }
    }   

    return success;
}

void output( const List *list )
{
    for ( const Node *current = list->head; current != NULL; current = current->next )
    {
        printf( "%d -> ", current->data );
    }

    puts( "null" );
}

int main(void) 
{
    List list = { .head = NULL, .tail = NULL };

    const int N = 10;

    for ( int i = 0; i < N; i++ )
    {
        if ( i % 2 != 0 )
        {
            push_front( &list, i );
        }
        else
        {
            push_back( &list, i );
        }

        output( &list );
    }

    return 0;
}

0 commentaires