C - Liste chainée

Aloaa -  
 Aloaa -
Bonsoir,

J'aimerai des explications sur les liste chainée , j'ia repris le code d'un tuto du site du zero , le voici :

#include <stdlib.h>

typedef struct element element;
struct element
{
int val;
struct element *nxt; // 1°
};

typedef element* llist;

int main(int argc, char **argv)
{
/* Déclarons 3 listes chaînées de façons différentes mais équivalentes */
llist ma_liste1 = NULL;
element *ma_liste2 = NULL;
struct element *ma_liste3 = NULL; // 2°

return 0;
}

Voilà le problème c'est que je n'arrive pas à comprendre correctement ce code ,
en gros ce que je comprend c'est que chaque element comprend une valeur et l'adresse de l'element suivant ( mais je ne sais pas pourquoi on déclare le pointeur avec "struct element" )
ensuite on créer llist qui "initialise" la formation d'une chaine en renvoyant son adresse(?)
et dans le main on initialise le 1er element à NULL ,
et pour rajouter un element , on recupere l'adresse de l'element creer , on le met l'element precedent ensuite on met *nxt de l'element en cours à NULL .

Merci beaucoup de prendre le temps de m'expliquer .

4 réponses

  1.
    info_Louka Messages postés 64 Date d'inscription   Statut Membre Dernière intervention  
     
    on déclare le pointeur par struct element parce il pointe sur un élément de type struct element qui va contenir aussi
    int val;
    struct element *nxt;
    0
    1. Aloaa
       
      merci, je comprend beaucoup mieux comme ça , je ne voyais pas ça comme ça dans ma tête.

      et pour
      typedef element* llist; , pourrias-tu expliquer avec tes mots ce que ça fait , et j'ai une question un
      peu hs , est-ce que
      typedef element * llist , typedef element *llist , typedef element* llist veut dire la meme chose ?

      merci bien
      0
  2. info_Louka Messages postés 64 Date d'inscription   Statut Membre Dernière intervention  
     
    typedef element* llist; revient à dire qu'en déclarant une variable de type element revient à declarer une variable de type llist

    d'aprè le code (typedef struct element *element; typedef element* llist; ) donne que les 3 types llist, element et struct element sont équivalent et donc

    llist ma_liste1 = NULL;
    element *ma_liste2 = NULL;
    et struct element *ma_liste3 = NULL;

    représentent la même chose
    0
    1. Aloaa
       
      Ah okayy , en faite typedef element* llist; ne sert que pour llist ma_liste1 = NULL; ?
      car je peux remplacer tout ça par les 2 derniers .
      0
    2. info_Louka Messages postés 64 Date d'inscription   Statut Membre Dernière intervention  
       
      et bien sur le meme nom de variable pas list1 et lis2
      0
    3. Aloaa
       
      ok merci en tout cas!!
      je m'exercerai demain sur tout ça .
      bonne nuit .
      0
    4. info_Louka Messages postés 64 Date d'inscription   Statut Membre Dernière intervention  
       
      de rien bnuit :)
      0
  3. info_Louka Messages postés 64 Date d'inscription   Statut Membre Dernière intervention  
     
    j'espère ke ca t'a aidé :))
    0
    1. Aloaa
       
      oui merci
      0
  4. Aloaa
     
    Hello , c'est encore moi

    merci info_Louka grâce a toi j'ai presque tout compris , mais là j'ai encore un soucis , je n'arrive pas a afficher les valeur de la liste chainée (dernière boucle) .

    Merci encore .

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

    typedef struct element element;
    struct element
    {
    int val;
    struct element *nxt; // *nxt pointe sur la structure suivante (qui contient aussi int val et *nxt
    };

    int main(int argc, char **argv)
    {
    element *Nouveau; //*Nouveau pointe sur un nouveau element quand on va le créer
    element *Courant; //*Courant pointe sur un element en cours (pour parcourir la liste chainée par ex)
    element *Tete; // *Tete pointe sur le premier element (pour savoir a quel adresse commence la liste chainée)
    Tete = NULL;

    Nouveau = (element*)malloc(sizeof(struct element)); //on créer le 1er element de la liste chainée
    Nouveau->nxt = Tete; //l'adresse du prochain element est null car il y en a pas encore
    Nouveau->val = 5 ;
    Tete = Nouveau ;//on met l'adresse du 1ere element dans le pointeur Tete

    Courant = Tete ; //on se placeau début de liste

    while(Courant->nxt != NULL) //on parcourt la liste jusqu'au dernier element
    {
    Courant = Courant->nxt; //on recupere l'adresse du dernier element a la fin de la boucle
    }
    Nouveau = (element*)malloc(sizeof(struct element));
    Courant->nxt = Nouveau; //on met l'adresse du nouveau element dans le dernier element en cours
    Nouveau->val = 10;
    Nouveau->nxt = NULL; //on met NULL pour le nouveau element ( qui est maintenant le dernier)

    Courant = Tete ; // on se place au debut de liste
    while(Courant->nxt != NULL)
    {
    printf("%d",Courant->val);
    Courant = Courant->nxt;
    }
    return 0;
    }
    0
    1. Aloaa
       
      ah ça y est j'ai réussi , il fallait rajouter printf("%d",Courant->val); apres la boucle pour avoir la valeur du dernier element , c'est obligé de faire ça ?
      0