Liste doublement chainée en C

Jarod -  
Bonjour à tous,
j'ai défini une liste chainée bidirectionnelle avc

typedef struct liste
{
struct liste *suivant;
struct liste *precedent;
int valeur;
}LISTE;

g une fonction insertion() ki insert des valeurs au fur et a mesure ds ma liste chainée, avc une allocation dynamique.

Puis apres je voudrai afficher ma liste ds l'ordre inverse(c'est a dire afficher la derniere valeur entrer jusqu'a la premiere) en me servant de *precedent. mais je n'y arrive pas.

Pouvez-vous m'aider svp à écrire la fonction insertion et d'affichage afin de permettre d'afficher dans l'ordre inverse?

Merci d'avance.
Cordialement.

5 réponses

  1.  maily Contributeur
    Je dirais qu'il faut parcourir 2 fois la liste chainée... ce n'est pas très pratique, mais bon, il n'y a que ça à mon avis! 

    void affichageFin (LISTE *fin) 
{ 
    LISTE *p; 
    LISTE * q;
    p=fin; 

    while (p != NULL) 
    { 
        q=p;
        p = p->suivant; 
    } 
    while(q!=NULL){
       p=q;
       q=q->precedent;
       printf("%d\n", p->valeur);
   }
}


    Maily :-))))
    Boumj'chtattrape
    1. maily Contributeur
      Bonjour!

      Pourrais tu mettre le code déjà écrit qu'on puisse partir d'une base s'il te plait? Comme ça, on ira plus vite pour t'aider!

      ;-)

      Maily :-))))
      Boumj'chtattrape
      1. Jarod
        voila le code ki me permet d'inserer des valeur en queue de chaine, et de les afficherdu debut à la fin. Pouvez vous m'aider a les afficher de la fin de la chine jusqu'au debut merci. 

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

typedef struct liste 
{ 
    struct liste *suivant; 
    struct liste *precedent; 
    int valeur; 

}LISTE; 

void affichage (LISTE *fin) 
{ 
    LISTE *p; 

    p=fin; 
    while (p != NULL) 
    { 
        printf ("%d\n", p->valeur); 
        p = p->suivant; 
    } 
} 

LISTE *insertion (int valeur, LISTE *p) 
{ 
    LISTE *nouveau; 

    p->precedent = p->suivant; 
    nouveau = malloc(sizeof(LISTE)); 

//    printf("%d,%d",p->precedent,p->suivant); 
    p->suivant = nouveau; 
    nouveau->suivant=NULL; 
    nouveau->valeur = valeur; 
    return nouveau; 
} 

int main () 
{ 
    int i, n; 
    LISTE *tete, *p; 

    printf ("Taille de la liste:"); 
    scanf ("%d", &n); 

    p = (LISTE*) &tete; 
    for (i=1; i<=n; i++) 
    { 
        p = insertion (i*i, p); 
    } 
    affichage(tete); 
}
        1. de passage...
          #include <stdio.h> #include <stdlib.h> typedef struct liste
          {
          struct liste *suivant;
          struct liste *precedent;
          int valeur;

          }LISTE;

          // tu peux utiliser le paramètre "alafin" dans la procédure
          // car tu ne modifies que la valeur locale (une copie sur la
          // pile du pointeur "p" passé en paramètre)
          void affichageFin (LISTE *alafin)
          {
          while (alafin != NULL)
          {
          printf("%d\n",alafin->valeur);
          alafin=alafin->precedent;
          }
          }
          void affichage (LISTE *fin)
          {
          LISTE *p;

          p=fin;
          while (p != NULL)
          {
          printf ("%d\n", p->valeur);
          p = p->suivant;
          }
          }

          LISTE *insertion (int valeur, LISTE *p)
          {
          LISTE *nouveau;

          p->precedent = p->suivant;
          nouveau = malloc(sizeof(LISTE));
          if (nouveau != NULL)
          {
          // on vérifie tjs un pointeur alloué!!!!
          // printf("%d,%d",p->precedent,p->suivant);
          p->suivant = nouveau;
          nouveau->suivant=NULL;
          nouveau->valeur = valeur;
          }
          return nouveau;
          }

          int main ()
          {
          int i, n;
          LISTE *tete, *p; /* *p est en fait ta fin de liste */

          printf ("Taille de la liste:");
          scanf ("%d", &n);

          p = (LISTE*) &tete; for (i=1; i<=n; i++)
          {
          p = insertion (i*i, p);
          }
          affichage(tete);
          affichagefin(p);
          }