LIste circulaire doublement chainee [Résolu/Fermé]

Signaler
Messages postés
1
Date d'inscription
lundi 26 novembre 2007
Statut
Membre
Dernière intervention
26 novembre 2007
-
 Anonyme -
Bonjour,

Besoin d'aide pour une demonstration, voila sur le net j'ai trouvé plus d'infos sur la liste doublement chainee, simple..
sauf pour la circulaire qui un peu plus delicate a manier.

Le probleme c'est que pour la circulaire on n'a pas de repere comme les autres listes avec le null ! (puisque le dernier noeud n'est pas lie au null mais au premier ..)

De plus quelle serait la fonction pour inserer n'importe quelle donnees exemple : inserer un tableau dynamique, chaine de caracteres..

J ai trouve tres interessant le cour de Mr lami20j sur la liste doublement chainee ca me serait tres utile si Je trouve un bon exemple sur la circuleire ,Merci votre aide me serait tres utiles et je l'espere pour d'autres aussi ..


voicie un exemple de module avec les entetes de fonctions type
/* liste.h : Module de listes generiques circulaires doublement chainees */
#ifndef LISTE_H
# define LISTE_H

typedef struct liste * liste;

/* listeCree
Cree une liste vide. Reussit toujours */
liste listeCree(void);

/* listeInsere
Insere un element après l'element courant de la liste l
L'element insere doit exister (i.e. valeur NULL non autorisee)
Renvoie la liste positionnee sur l'element insere si l'insertion reussit
Renvoie NULL sinon */
liste listeInsere(liste l, void * element);

/* listePrecedent
Positionne la liste sur l'element precedant l'element courant
Renvoie NULL en cas d'echec */
liste listePrecedent(liste l);

/* listeSuivant
Positionne la liste sur l'element qui suit l'element courant
Renvoie NULL en cas d'echec */
liste listeSuivant(liste l);

/* listeLit
Renvoie l'element courant (sans changer le positionnement dans la liste)
Renvoie NULL en cas de probleme */
void * listeLit(liste l);

#endif /* LISTE_H */

4 réponses

Bonjour

Liste doublement chaînée
Astuces / Programmation / Langages / Langage C
https://www.commentcamarche.net/faq/7636-liste-doublement-chainee
Publié par lami20j, dernière mise à jour le vendredi 7 décembre 2007 à 21:16:59 par lami20j

Liste simplement chaînée
Astuces / Programmation / Langages / Langage C
https://www.commentcamarche.net/faq/7444-liste-simplement-chainee
Publié par lami20j, dernière mise à jour le vendredi 7 décembre 2007 à 21:15:59 par lami20j

Quid d'une info lami20j sur ccm sur "Le problème de Josephus" ? = Trouver la place sûre.
Vous pouvez en lire plus sur Josephus Flavius à travers cet article sur Wikipedia en anglais.

Merci
2
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 65492 internautes nous ont dit merci ce mois-ci

salut
je vous remerci pour votre cyte je suis tres besion correction d'alghoritme de circulation de liste chainne et te remeci a out les prof
je me demande bien si Monsieur Chieze a la réponse à cette question...demandez-lui!
Messages postés
21331
Date d'inscription
jeudi 4 novembre 2004
Statut
Modérateur, Contributeur sécurité
Dernière intervention
30 octobre 2019
3 522
Salut,

si Je trouve un bon exemple sur la circuleire
En fait je suis en train de préparer un tuto, mais l'implémentation est faite avec une liste simplement chaînée (voici le code, mais je ne l'ai pas encore tester

A ne pas oublier, que le plus important c'est de comprendre le fonctionnement. L'implémentation c'est en fonction de ce qu'on veut faire.
liste_circ.h
/* ---------- liste_circ.h ----------- */
typedef struct ElementListeCirc {
    char *donnee;
    struct ElementListeCirc *suivant;
} Element;

typedef struct ListeRepereCirc {
    Element *debut;
    int taille;
} Liste;

/* initialisation de la liste */
void initialisation (Liste * liste);

/* INSERTION */
/* insertion dans une liste vide */
int ins_liste_circ(Liste * liste, Element *courant, char *donnee);

/* SUPPRESSION */
int supp_liste_circ (Liste * liste, Element *courant);

int menu (Liste *liste);
void affiche (Liste * liste);
void affiche_infini (Liste * liste);
void detruire (Liste * liste);
/* -------- FIN liste_circ.h --------- */ 
liste_circ_function.h
/******************************\
    * liste_circ_function.h *
\******************************/
void initialisation (Liste * liste){
    liste->debut = NULL;
    liste->taille = 0;
}

/* insertion dans une liste vide */
int ins_liste_circ (Liste * liste, Element *courant, char *donnee){
    Element *nouveau_element;
    if ((nouveau_element = (Element *) malloc (sizeof (Element))) == NULL)
return -1;        
    if ((nouveau_element->donnee = (char *) malloc (50 * sizeof (char)))
            == NULL)
        return -1;
    strcpy (nouveau_element->donnee, donnee);
    if(liste->taille == 0){
        nouveau_element->suivant = nouveau_element;
        liste->debut = nouveau_element;
    } else {
        nouveau_element->suivant = courant->suivant;
        courant->suivant = nouveau_element;
    }
    liste->taille++;
    return 0;
}

/* suppression dans la liste */
int supp_liste_circ(Liste * liste,Element *courant){
    if (liste->taille == 0)
        return -1;
    Element *supp_element;
    if(courant->suivant == courant){
        supp_element = courant->suivant;
        liste->debut = NULL;
    } else {
        supp_element = courant->suivant;
        courant->suivant = courant->suivant->suivant;
    }
    free (supp_element->donnee);
    free (supp_element);
    liste->taille--;
    return 0;
}

/* affichage de la liste */
void affiche (Liste * liste){
    Element *courant;
    courant = liste->debut;
    int i;
    for(i=0;i<liste->taille;++i){
        printf ("%p - %s\n", courant, courant->donnee);
        courant = courant->suivant;
    }
}

/* parcourir la liste à l'infini*/
void affiche_infini (Liste * liste){
    Element *courant;
    courant = liste->debut;
    while (1){
        printf ("%p - %s\n", courant, courant->donnee);
        courant = courant->suivant;
    }
}

/* detruire la liste */
void detruire (Liste * liste){
    while (liste->taille > 0)
        supp_liste_circ (liste,liste->debut);
}

int menu (Liste *liste){
    int choix;     printf("********** MENU **********\n");
    if (liste->taille == 0){
        printf ("1. Ajout du 1er element\n");
        printf ("2. Quitter\n");
    }else {         printf ("1. Ajout d'un élément\n");
        printf ("2. Suppression d'un élément\n");
        printf ("3. Affiche liste circulaire [Ctrl-C] pour quitter\n");
        printf ("4. Detruire la liste\n");
        printf ("5. Quitter\n");
    }
    printf ("\n\nFaites votre choix : ");
    scanf ("%d", &choix);
    getchar();
    if(liste->taille == 0 && choix == 2)
        choix = 5;
    return choix;
}
/* -------- FIN liste_circ_function --------- */ 
liste_circ.c
/**********************\
    * liste_circ.c *
\**********************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "liste_circ.h"
#include "liste_circ_function.h"

int main (void)
{
    char choix;
    char *nom;
    Liste *liste;
    Element *courant;


    if ((liste = (Liste *) malloc (sizeof (Liste))) == NULL)
    return -1;
    if ((nom = (char *) malloc (50)) == NULL)
        return -1;
    courant = NULL;
    choix = 'o';

    initialisation (liste);

    while (choix != 5){
        choix = menu (liste);
        switch (choix){
            case 1:
                printf ("Entrez un element : ");
                scanf ("%s", nom);
                getchar ();
                ins_liste_circ (liste,liste->debut,nom);
                printf ("%d elements:deb=%s\n", liste->taille,
                    liste->debut->donnee);
                affiche (liste);
                break;
            case 2:
                supp_liste_circ (liste,liste->debut);
                if (liste->taille != 0)
                printf ("%d elements:deb=%s\n", liste->taille,
                    liste->debut->donnee);
                else
                    printf ("liste vide\n");
                affiche (liste);
                break;
            case 3:
                affiche_infini(liste);
                break;
            case 4:
                detruire (liste);
                printf ("la liste a ete detruite : %d elements\n", liste->taille);
                break;
        }
    }
    return 0;
}