1/

IMPLÉMENTATION

Une liste chaînée est constituée de « maillons » ;

les maillons contiennent des données et l’adresse
d’un autre maillon. Les données contenues par les
maillons sont du même type d’un maillon à l’autre.
Une liste chaînée composée des entiers 12, 99 et 37
pourra être représentée comme suit :

2/
IMPLÉMENTATION

Le maillon qui se trouve à l’adresse début contient

l’élément qui constitue la tête de la liste. Pour
accéder à l’ensemble des éléments de la liste, on
part de l’adresse début. On peut avec cette adresse
accéder au premier maillon. On connaît ainsi le
premier élément de la liste et on lit l’adresse
contenue dans ce premier maillon, qui est celle du
deuxième maillon ; on peut alors accéder au
deuxième maillon pour connaître le deuxième
élément de la liste et ainsi de suite.

3/
IMPLÉMENTATION

Il est nécessaire qu’une adresse spéciale soit mise

dans le dernier maillon de la liste pour qu’on
puisse savoir qu’il s’agit du dernier maillon. Cette
adresse spéciale est prévue par les langages de
programmation qui permettent de manipuler les
listes chaînées ; elle s’appelle en général null ; c’est
toujours en quelque sorte l’adresse qui vaut zéro,
notée adresse nulle sur notre schéma.

4/
IMPLÉMENTATION

La gestion informatique d’une liste chaînée se fait

généralement en employant une allocation
dynamique de mémoire chaque fois qu’un
nouveau maillon est nécessaire. Néanmoins, on
peut gérer une structure de liste chaînée avec un
tableau de maillons, les adresses de maillons
devenant alors des indices du tableau ; avec cette
dernière façon de faire, on retrouve l’inconvénient
de la limitation du nombre de données au nombre
de cases du tableau de maillons.

5/
LISTES SIMPLEMENT CHAÎNÉES

Les listes chaînées sont des structures de données

semblables aux tableaux sauf que l'accès à un
élément ne se fait pas par index mais à l'aide d'un
pointeur.

6/
LISTES SIMPLEMENT CHAÎNÉES
En revanche, par rapport aux tableaux où les
éléments sont contigus dans la mémoire, les
éléments d'une liste sont éparpillés dans la
mémoire. La liaison entre les éléments se fait grâce
à un pointeur.
Le pointeur suivant du dernier élément doit pointer
vers NULL (la fin de la liste).
Pour accéder à un élément, la liste est parcourue
en commençant par la tête, le pointeur suivant
permettant le déplacement vers le prochain
élément. Le déplacement se fait dans une seule
direction, du premier vers le dernier élément.
7/
LISTES SIMPLEMENT CHAÎNÉES
Pour définir un élément de la liste le type struct
sera utilisé. L'élément de la liste contiendra un
champ donnée et un pointeur suivant. Le pointeur
suivant doit être du même type que l'élément,
sinon il ne pourra pas pointer vers l'élément. Le
pointeur "suivant" permettra l'accès vers le
prochain élément.
typedef struct ElementListe {
char *donnee;
struct ElementListe *suivant;
}Element;
8/
LISTES SIMPLEMENT CHAÎNÉES
Pour avoir le contrôle de la liste il est préférable de
sauvegarder certains éléments : le premier
élément, le dernier élément, le nombre d'éléments.
Pour réaliser cela une autre structure sera utilisée
(ce n'est pas obligatoire, des variables peuvent être
utilisées). Voici sa composition :
typedef struct ListeRepere {
Element *debut;
Element *fin;
int taille ;
}Liste ;
9/
LISTES SIMPLEMENT CHAÎNÉES
Le pointeur debut contiendra l'adresse du premier
élément de la liste. Le pointeur fin contiendra
l'adresse du dernier élément de la liste. La variable
taille contient le nombre d'éléments.
Quelle que soit la position dans la liste, les
pointeurs debut et fin pointent toujours
respectivement vers le premier et le dernier
élément.
Le champ taille contiendra le nombre d'éléments
de la liste quelle que soit l'opération effectuée sur
la liste.

10 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Pour ajouter un élément dans la liste il y a plusieurs
situations :
1. Insertion dans une liste vide
2. Insertion au début de la liste
3. Insertion à la fin de la liste
4. Insertion ailleurs dans la liste

11 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Insertion dans une liste vide
int ins_liste_vide (Liste *liste, char *donnee);
Étapes :
–remplir le champ de données du nouvel élément ;
–lepointeur suivant du nouvel élément pointera
vers NULL ;
–les pointeurs debut et fin pointeront vers le
nouvel élément ;
–la taille est mise à jour.

12 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

13 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
int ins_liste_vide (Liste * liste, char *donnee)
{
Element *nouveau_element;
strcpy (nouveau_element->donnee, donnee);
nouveau_element->suivant = NULL;
liste->debut = nouveau_element;
liste->fin = nouveau_element;
liste→taille++;
return 0;
14 /
}
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Insertion au début de la liste
int ins_debut_liste (Liste *liste,char *donnee);
Étapes:
–remplir le champ de données du nouvel élément ;
–lepointeur suivant du nouvel élément pointe vers le
1er élément ;
–le pointeur debut pointe vers le nouvel élément ;
–le pointeur fin ne change pas ;
–la taille est incrémentée.

15 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

16 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
int ins_debut_liste (Liste * liste, char *donnee){
Element *nouveau_element;
strcpy (nouveau_element->donnee, donnee);
nouveau_element->suivant = liste->debut;
liste->debut = nouveau_element;
liste->taille++;
return 0;
}

17 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Insertion à la fin de la liste
int ins_fin_liste (Liste *liste, Element *courant, char
*donnee);
Étapes:
–remplir le champ de données du nouvel élément ;
–le pointeur suivant du dernier élément pointe vers
le nouvel élément ;
–le pointeur fin pointe vers le nouvel élément ;
–le pointeur debut ne change pas ;
–la taille est incrémentée.
18 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

19 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
int ins_fin_liste (Liste * liste, Element * courant, char
*donnee)
{
Element *nouveau_element;
strcpy (nouveau_element->donnee, donnee);
courant->suivant = nouveau_element;
nouveau_element->suivant = NULL;
liste->fin = nouveau_element;
liste->taille++;
return 0;
} 20 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Insertion ailleurs dans la liste
int ins_liste (Liste *liste, char *donnee,int pos);
L'insertion s'effectuera après une certaine position
passée en argument à la fonction.
Étapes:
–remplir le champ de données du nouvel élément ;

–choisir une position dans la liste (l'insertion se fera

après la position choisie) ;

21 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

–le pointeur suivant du nouvel élément pointe vers

l'adresse sur laquelle pointe le pointeur suivant
d'élément courant.
–le pointeur suivant du l'élément courant pointe vers
le nouvel élément ;
–les pointeurs debut et fin ne changent pas ;
–la taille est incrémentée d'une unité.

22 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

23 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
int ins_liste (Liste * liste, char *donnee, int pos)
{
if (liste->taille < 2)
return -1;
if (pos < 1 || pos >= liste->taille)
return -1;
Element *courant;
Element *nouveau_element;
int i;

24 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
courant = liste->debut;
for (i = 1; i < pos; ++i)
courant = courant->suivant;
if (courant->suivant == NULL)
return -1;
strcpy (nouveau_element->donnee, donnee);
nouveau_element->suivant = courant >suivant;
courant->suivant = nouveau_element;
liste->taille++;
return 0;
25 /
}
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Pour supprimer un élément dans la liste il y a
plusieurs situations :
1. Suppression au début de la liste
2. Suppression ailleurs dans la liste

26 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Suppression au début de la liste
int supp_debut (Liste *liste);
Étapes:
–lepointeur supp_elem contiendra l'adresse du 1er
élément
–le pointeur debut pointera vers le 2ème élément
–la taille de la liste sera décrémentée d'un élément

27 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

28 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
int supp_debut (Liste * liste){
if (liste->taille == 0)
return -1;
Element *supp_element;
supp_element = liste->debut;
liste->debut = liste->debut->suivant;

29 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
if (liste->taille == 1)
liste->fin = NULL;
free (supp_element->donnee);
free (supp_element);
liste->taille--;
return 0;
}

30 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Suppression ailleurs dans la liste
int supp_dans_liste (Liste *liste, int pos);
Étapes:
–lepointeur supp_elem contiendra l'adresse vers
laquelle pointe le pointeur suivant d'élément
courant
–le pointeur suivant de l'élément courant pointera
vers l'élément sur lequel pointe le pointeur suivant
de l'élément qui suit l'élément courant dans la liste

31 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Si l'élément courant est l'avant dernier
élément, le pointeur fin doit être mis à jour
–la taille de la liste sera décrémentée d'un
élément

32 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

33 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

34 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

int supp_dans_liste (Liste * liste, int pos){

if (liste->taille <= 1 || pos < 1 || pos >= liste->taille)
return -1;
int i;
Element *courant;
Element *supp_element;
courant = liste->debut;

35 /
 OPÉRATIONS SUR LES LISTES CHAÎNÉES
for (i = 1; i < pos; ++i)
courant = courant->suivant;
supp_element = courant->suivant;
courant->suivant = courant->suivant->suivant;
if(courant->suivant == NULL)
liste->fin = courant;
free (supp_element->donnee);
free (supp_element);
liste->taille--;
return 0; 36 /

}
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Affichage de la liste
Pour afficher la liste entière il faut se positionner au
début de la liste (le pointeur debut le permettra).
Ensuite en utilisant le pointeur suivant de chaque
élément, la liste est parcourue du 1er vers le dernier
élément.
La condition d'arrêt est donnée par le pointeur suivant
du dernier élément qui vaut NULL.

37 /
 OPÉRATIONS SUR LES LISTES CHAÎNÉES
void affiche (Liste * liste)
{
Element *courant;
courant = liste->debut;
while (courant != NULL){
printf ("%p - %s\n", courant, courant->donnee);
courant = courant->suivant;
}
}
38 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES
Pour détruire la liste entière, on utilise la suppression
au début de la liste tant que la taille est plus grande
que zéro.

void detruire (Liste * liste)

{
while (liste->taille > 0)
supp_debut (liste);
}

39 /
OPÉRATIONS SUR LES LISTES CHAÎNÉES

EXEMPLE COMPLET

40 /