les listes simplement chaînées en c

8/14/2019 Les Listes Simplement Chanes en C

1/21

Les listes simplement chanes en C

par Nicolas Joseph (home) (Blog)

Date de publication : 29 Juin 2005

Dernire mise jour : 24 Aot 2005

Les structures de donnes en C.

Premire partie : les listes simplement chanes.
http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


2/21

Les listes simplement chanes en C par Nicolas Joseph (home) (Blog)

- 2 -Les sources prsents sur cette pages sont libres de droits, et vous pouvez les utiliser votre convenance. Par contre la page de prsentation deces sources constitue une oeuvre intellectuelle protge par les droits d'auteurs. Copyright 2006 - Nicolas Joseph. Aucune reproduction, mmepartielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur.Sinon vous encourez selon la loi jusqu' 3 ans de prison et jusqu' 300 000 E de dommages et intrts.

http://nicolasj.developpez.com/articles/listesimple/

Historique24 Aot 200529 Juin 2005

I - IntroductionII - PrincipeIII - La pratique

III-A - Les conventions de nommageIII-B - La structure d'un maillonIII-C - InitialisationIII-D - Insertion d'un lmentIII-E - Suppression d'un lmentIII-F - Suppression du premier lment de la listeIII-G - Accs l'lment suivantIII-H - Accs aux donnes stockesIII-I - Accs au premier lment de la liste

III-J - Accs au dernier lment de la listeIII-K - Calcul de la taille de la listeIII-L - Suppression de la liste

IV - ConclusionV - Autres documentationsVI - RemerciementsVIII - Code source complet
http://nicolasj.developpez.com/articles/listesimple/http://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


3/21




Historique

24 Aot 2005

Rectification de deux fuites mmoire dans sll_delete

sll_nextne retourne plus un int

sll_insert, sll_removeNex, sll_removeFirst, sll_next, sll_firstet sll_lastprennent maintenant en argument un pointeursur la liste, et ont t modifies en consquence

29 Juin 2005

Premire publication


4/21




I - Introduction

Voici le premier tutoriel d'une future srie qui traitera des structures de donnes en C; il s'adresse aux personnesayant une bonne connaissance de ce langage, il est conseill d'avoir lu un livre tel que celui de B. Kernighan et D.Ritchie : Le langage C, norme ANSI. Cette suite de tutoriels a pour but de vous fournir les bases pour comprendrel'implmentation de ces structures. Cette suite d'articles portera sur :

Les listes simplement chanes (c'est l'article que vous tes en trains de lire)

Les listes doublement chanes

Les piles

Les files

Les tables de hachage

Les arbres

Les graphes

Au terme de chaque tutoriel, vous disposerez d'une bibliothque comportant les fonctions principales de manipulationde la structure de donnes aborde dans celui-ci.


5/21




II - Principe

La structure la plus utilise pour manipuler des donnes est le tableau, qui contrairement aux listes chanes, estimplment de faon native dans le langage C. Cependant dans certains cas, les tableaux ne constituent pas lameilleure solution pour stocker et manipuler les donnes. En effet, pour insrer un lment dans un tableau, il fautd'abord dplacer tous les lments qui sont en amont de l'endroit o l'on souhaite effectuer l'insertion, ce qui peutprendre un temps non ngligeable proportionnel la taille du tableau et l'emplacement du futur lment. Il en estde mme pour la suppression d'un lment; bien sr ceci ne s'applique pas en cas d'ajout ou de suppression enfin de tableau. Avec une liste chane, le temps d'insertion et de suppression d'un lment est constant quelquesoit l'emplacement de celui-ci et la taille de la liste. Elles sont aussi trs pratiques pour rarranger les donnes, cetavantage est la consquence directe de la facilit de manipulation des lments.

Plus concrtement, une liste simplement chane est en fait constitue de maillons ayant la possibilit de pointervers une donne accessible et modifiable par l'utilisateur ainsi qu'un lien vers le maillon suivant. La figure suivante

reprsente de faon schmatique un lment de ce type :

Figure 1 : reprsentation d'un lment d'une liste simplement chane.

Une liste chane tant une succession de maillons, dont le dernier pointe vers adresse invalide (NULL); voici unereprsentation possible :

Figure 2 : reprsentation d'une liste chane en mmoire.

Bien sr, ce n'est qu'une reprsentation, il se peut que les structures qui composent la liste ne soit pas places dansl'ordre en mmoire et encore moins de faon contigu.

Au vu de l'utilisation des listes chanes, il se dessine clairement quelques fonctions indispensables :

Initialisation

Ajout d'un lment

Suppression d'un lment

Accs l'lment suivant

Accs aux dones utilisateur

Accs au premier lment de la liste

Accs au dernier lment de la liste

Calcul de la taille de la liste

Suppression de la liste entire

Le principal problme des listes simplement chanes est l'absence de pointeur sur l'lment prcdent du maillon, il

est donc possible de parcourir la chane uniquement du dbut vers la fin. Pour faciliter l'implmentation, nous allonsfaire quelques simplifications :


6/21




Sauvegarde du premier lment de la chane, ceci permet de retourner au dbut de la liste,

L'ajout s'effectue la suite de l'lment spcifi en paramtre de la fonction.

Voici donc la reprsentation dfinitive de notre structure en mmoire, start reprsentent le pointeur ddi lasauvegarde du premier lment de la liste :

Figure 3 : organisation de la liste chane dans notre programme.

De plus, j'ai choisi de passer en argument, aux fonctions publiques utilises pour manipuler des listes, un pointeurde pointeur sur la liste chane , il est aussi possible de passer un pointeur sur cette liste et de lui faire retourner lanouvelle liste chane. Cependant, j'ai prfr la premire solution pour plusieurs raisons :

Le passage par pointeur permet la fonction appelante de modifier directement la liste,

La valeur de retour de la fonction peut tre utilise pour d'autre chose : gestion des erreurs par exemple.

L'lment supprim sera celui qui suit l'lment pass en paramtre et non lui-mme tout simplement parcequ'il n'est pas possible d'accder simplement au maillon prcdent pour mettre NULL son pointeur surl'lment suivant et actualiser le pointeur sur l'lment de fin, lors de la suppression du dernier lment.
http://nicolasj.developpez.com/articles/listesimple/http://nicolasj.developpez.com/articles/listesimple/http://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


7/21




III - La pratique

III-A - Les conventions de nommage

Dernier point avant de passer au code proprement parler,, je vais m'attarder sur les conventions de nommageutiliss pour permettre une meilleure comprhension du code :

Le suffixe_ssignifie qu'il s'agit d'un tydedef de structure,

Le prfixe p_ est utilis pour les noms des pointeurs,

Les fonctions publiques de la bibliothque commencent par le prfixe sll_ pour Singly-Linked Lists (soit listessimplement chanes en franais).

Ceci tant fix, je vais maintenant vous prsenter les diffrentes fonctions accompagnes des explicationsncessaires pour comprendre leur fonctionnement.

III-B - La structure d'un maillon

A partir de la figure 1, la transition de cette reprsentation en structure au sens du langage C est simple; en effet, ilnous faut un pointeur gnrique pour les donnes de l'utilisateur et un pointeur sur l'lment suivant :

typedefstruct item

{

struct item *next;

void*data;

} item_s;

Avec :

next: un pointeur sur le maillon suivant ou NULL s'il s'agit du dernier

data: un pointeur gnrique vers la donne stocke par l'utilisateur

Pour pouvoir sauvegarder certains lments spcifiques de chaque liste tel que le premier lment et l'lmentcourant, il faut crer un nouveau type de structure :

typedefstruct sll

{

item_s *p_start;item_s *list;

} sll_s;

Avec :

p_start: le premier lment de la liste

list: l'lment courant

Il est bien sr possible d'en ajouter d'autre, tel qu'un pointeur sur le dernier lment ou encore un compteur pour lenombre d'lments que contient la liste.

La structure sll_ssera la structure passer en paramtre chaque fonction de la bibliothque.


8/21




III-C - Initialisation

Cette fonction est appeler avant toutes les autres : elle cre la structure qui va contenir la liste chane ainsi quele premier lment qui va servir de sentinelle.

sll_s *sll_new (void)

{

sll_s *p_sll = malloc (sizeof*p_sll);

if (p_sll)

{

item_s *p_l = malloc (sizeof*p_l);

if (p_l)

{

p_l->data =NULL;

p_l->next =NULL;

p_sll->p_start = p_l;

p_sll->list =NULL;

}

else

{

fprintf (stderr, "Memoire insufisante\n");

exit (EXIT_FAILURE);

}

}

else

{



}

return p_sll;

}

III-D - Insertion d'un lment

Cette fonction a pour but de crer un nouvel lment et de l'insrer dans la liste juste aprs l'lment courant de la liste.Il ne faut pas oublier de vrifier si la liste est vide (dans ce cas, p_sll->listest gale NULL). Voici la schmatisationcorrespondante, pour simplifier la sentinelle p_starta t omise :


9/21




Figure 4 : reprsentation de l'insertion d'un lment.

1 Voici l'tat de la liste avant l'appel de la fonction2 Le pointeur p_lreprsente l'argument de la fonction, c'est donc aprs lui qu'il faut insrer un maillon3 Cration d'un nouvel lment point par p_n4 On commence par faire pointer le nouvel lment sur le maillon qui suit p_l5 Puis on modifie p_lpour que l'lment qui le suit soit celui nouvellement cr6 Etat de la liste aprs l'appel de la fonction

Le plus gros du travail a t ralis, de ce fait, le code en C ne ncessite pas de commentaire. S'il y a une erreurde mmoire la liste n'est pas modifie :

void sll_insert (sll_s * p_sll, void*data)

{

if (p_sll)

{/* (2) */

item_s *p_l = p_sll->list;


10/21




item_s *p_n =NULL;

/* (3) */

p_n = malloc (sizeof (*p_n)); if (p_n)

{

p_n->data = data;

if (p_l ==NULL)

{

p_sll->p_start->next = p_n;

p_n->next =NULL;

}

else

{

/* (4) */

p_n->next = p_l->next;

/* (5) */

p_l->next = p_n;

}

/* (6) */

p_sll->list = p_n;

}

else

{

fprintf (stderr, "Memoire insuffisante\n");


}

}

}

III-E - Suppression d'un lment

Aprs avoir ajout un lment, il est intressant de voir comment en enlever. Comme spcifi dans le paragrapheexposant le principe, c'est l'lment suivant celui spcifi en paramtre qui est supprim, par consquent on ne peutpas passer le dernier lment de la liste cette fonction, et il est aussi impossible de supprimer le premier lmentde cette manire. Voici la schmatisation correspondante, pour simplifier p_startest toujours absent du schma :


11/21




Figure 5 : reprsentation de la suppression d'un lment.

1 Voici l'tat de la liste avant l'appel de la fonction

2 Le pointeur p_lreprsente l'argument de la fonction, c'est donc l'lment suivant qu'il faut supprimer3 Sauvegarde de l'lment supprimer grce au pointeur p_n4 Modification du pointeur sur l'lment suivant pour qu'il pointe sur l'lment qui suit immdiatement celui

supprimer5 Libration de la mmoire6 tat de la liste aprs l'appel de la fonction

Maintenant passons au code :

void sll_removeNext (sll_s * p_sll)

{

if (p_sll && p_sll->list)

{

/* (2) */


item_s *p_n =NULL;

/* (3) */

p_n = p_l->next;

/* (4) */

p_l->next = p_n->next;

/* (5) */

free (p_n);

p_n =NULL;

}

}

III-F - Suppression du premier lment de la liste


12/21




Avec la fonction sll_removeNext, il est impossible de supprimer le premier lment de la liste puisque l'utilisateur n'apas accs la sentinelle, c'est pourquoi on est oblig de crer une fonction spciale qui va supprimer cet lmenten passant la sentinelle la fonction sll_removeNext:

void sll_removeFirst (sll_s * p_sll)

{

if (p_sll)

{

p_sll->list = p_sll->p_start;

sll_removeNext (p_sll);

}

}

III-G - Accs l'lment suivant

Cette fonction se contente de retourner l'lment suivant dans la liste, en faisant tout de mme attention la valeurde p_l:

void sll_next (sll_s * p_sll)

{


{

p_sll->list = p_sll->list->next;

}

}

III-H - Accs aux donnes stockes

Les listes chanes permettent l'utilisateur de stocker des donnes, il est donc normal qu'il puisse y accder :

void*sll_data (sll_s * p_sll)

{

return ((p_sll && p_sll->list) ? p_sll->list->data : NULL);

}

III-I - Accs au premier lment de la liste

Cette fonction est rendue extrmement simple par l'existence de la sentinelle :

void sll_first (sll_s * p_sll)

{

if (p_sll)

{

p_sll->list = p_sll->p_start->next;

}

}

III-J - Accs au dernier lment de la liste

Contrairement la fonction prcdente, on n'a pas de sentinelle pointant sur le dernier lment, par consquent,pour le retrouver, il faut parcourir la liste jusqu' tomber sur le pointeur NULL :

vvoid sll_last (sll_s * p_sll){

if (p_sll)
http://nicolasj.developpez.com/articles/listesimple/http://nicolasj.developpez.com/articles/listesimple/http://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


13/21




{

while (p_sll->list->next !=NULL)

{

sll_next (p_sll); }

}

}

III-K - Calcul de la taille de la liste

Cette fonction retourne le nombre d'lments prsents dans la liste et ce en partant du dbut de la liste et enincrmentant le nombre d'lments jusqu' arriver la fin de la liste en utilisant la proprit de la fonction sll_nextqui retourne NULL en fin de liste :

size_t sll_sizeof (sll_s * p_sll)

{ size_t n =0;

if (p_sll)

{

sll_first (p_sll);

while (p_sll->list !=NULL)

{

n++;

sll_next (p_sll);

}

}

return n;

}

III-L - Suppression de la liste

Voici la dernire fonction de notre bibliothque, il s'agit d'une fonction permettant de dtruire entirement la liste encommenant par le premier lment et de supprimer chaque lment jusqu'au dernier, ou plus prcisment jusqu'ce que le premier lment devienne le dernier puis celui-ci est supprim manuellement.

void sll_delete (sll_s ** pp_sll)

{

if (pp_sll &&*pp_sll)

{

sll_first (*pp_sll);

while ((*pp_sll)->list->next !=NULL)

{sll_removeNext (*pp_sll);

}

sll_removeFirst (*pp_sll);

free ((*pp_sll)->list);

(*pp_sll)->list =NULL;

free (*pp_sll), *pp_sll =NULL;

}

}


14/21




IV - Conclusion

Il existe bien d'autres fonctions coder mais cet exemple se veut lger (j'utilise la version doublement chanepour crer un script CGI universel donc il est important que le programme rsultant soit le plus lger possible pouramliorer son utilisation via l'internet). Cependant si vous souhaitez complter cette bibliothque, ce qui est un trsbon exercice, vous pouvez vous inspirer des fonctions prsentent dans la glib. Voil, c'est la fin de ce premier articled'une longue srie, en esprant vous avoir transmis ma passion pour le C au travers de celui-ci et aussi vous donnerenvie de lire la suite.
http://nicolasj.developpez.com/articles/listesimple/http://developer.gnome.org/doc/API/2.0/glib/index.htmlhttp://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


15/21




V - Autres documentations

Liste simplement chane par CGI
http://nicolasj.developpez.com/articles/listesimple/http://chgi.developpez.com/pile/http://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


16/21




VI - Remerciements

Un grand merci Emmanuel Delahaye pour ses conseils et les corrections qu'il a apport au code de la bibliothque

Merci Anomaly et MD Software pour leur relecture attentive de cet article


17/21




VIII - Code source complet

Voici le code complet de la bibliothque (tlchargez l'archive zippe) avec un fichier main.c pour illustrer sonutilisation, pour ne pas manquer la tradition, il s'agit d'un programme qui affiche "Hello world!" en utilisant la plupartdes fonctions vues prcdemment.

listesimple.h#ifndef H_LISTESIMPLE

#define H_LISTESIMPLE

#include /* pour size_t */

typedefstruct sll sll_s;

sll_s *sll_new (void);

void sll_insert (sll_s *, void*);

void sll_removeNext (sll_s *);

void sll_removeFirst (sll_s *);

void sll_next (sll_s *);

void*sll_data (sll_s *);

void sll_first (sll_s *);

void sll_last (sll_s *);

size_t sll_sizeof (sll_s *);

void sll_delete (sll_s **);

#endif/* not H_LISTESIMPLE */

listesimple.c#include

#include

#include "listesimple.h"

typedefstruct item

{

struct item *next;

void*data;

} item_s;

struct sll

{

item_s *p_start;

item_s *list;

};

sll_s *sll_new (void)

{

sll_s *p_sll = malloc (sizeof*p_sll);

if (p_sll)

{

item_s *p_l = malloc (sizeof*p_l);

if (p_l)

{

p_l->data =NULL;

p_l->next =NULL;

p_sll->p_start = p_l;

p_sll->list =NULL;

}

else

{fprintf (stderr, "Memoire insufisante\n");

http://nicolasj.developpez.com/articles/listesimple/ftp://www.ftp-developpez.com/nicolasj/listesimple.ziphttp://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072


18/21




listesimple.c }

}

else {



}

return p_sll;

}

void sll_insert (sll_s * p_sll, void*data)

{

if (p_sll)

{


item_s *p_n =NULL;

p_n = malloc (sizeof (*p_n));

if (p_n)

{

p_n->data = data;

if (p_l ==NULL)

{

p_sll->p_start->next = p_n;

p_n->next =NULL;

}

else

{

p_n->next = p_l->next;

p_l->next = p_n;

}

p_sll->list = p_n;

}

else {

fprintf (stderr, "Memoire insuffisante\n");


}

}

}

void sll_removeNext (sll_s * p_sll)

{


{


item_s *p_n =NULL;

p_n = p_l->next;p_l->next = p_n->next;

free (p_n);

p_n =NULL;

}

}

void sll_removeFirst (sll_s * p_sll)

{

if (p_sll)

{

p_sll->list = p_sll->p_start;

sll_removeNext (p_sll);

}

}

void sll_next (sll_s * p_sll){



19/21




listesimple.c {

p_sll->list = p_sll->list->next;

}}

void*sll_data (sll_s * p_sll)

{

return ((p_sll && p_sll->list) ? p_sll->list->data : NULL);

}

void sll_first (sll_s * p_sll)

{

if (p_sll)

{

p_sll->list = p_sll->p_start->next;

}

}

void sll_last (sll_s * p_sll)

{

if (p_sll)

{

while (p_sll->list->next !=NULL)

{

sll_next (p_sll);

}

}

}

size_t sll_sizeof (sll_s * p_sll)

{

size_t n =0;

if (p_sll) {

sll_first (p_sll);

while (p_sll->list !=NULL)

{

n++;

sll_next (p_sll);

}

}

return n;

}

void sll_delete (sll_s ** pp_sll)

{

if (pp_sll &&*pp_sll)

{ sll_first (*pp_sll);

while ((*pp_sll)->list->next !=NULL)

{

sll_removeNext (*pp_sll);

}

sll_removeFirst (*pp_sll);

free ((*pp_sll)->list);

(*pp_sll)->list =NULL;

free (*pp_sll), *pp_sll =NULL;

}

}

main.c#include #include

#include "listesimple.h"


20/21




main.c

staticvoid list_print (sll_s *);

int main (void)

{

sll_s *p_sll =NULL;

char text[][6] ={"Hello", " ", "World", "!"};

printf ("\t-- Initialisation --\n");

p_sll = sll_new ();

list_print (p_sll);

printf ("\n\t-- Insertion --\n");

{

int i;

for (i =0; i


21/21


21
http://nicolasj.developpez.com/articles/listesimple/http://blog.developpez.com/?blog=58http://nicolasj.developpez.com/http://www.developpez.net/forums/member.php?u=41072

les listes simplement chaînées en c

Documents