Vous êtes sur la page 1sur 11

Les structures dynamiques

II. Les listes chainées(les structures récursives)


1-Définition :
Les structures récursives font références à elles même, on cite les listes, les piles,
les files et arbres.
La liste chainée est une structure dynamique (l’espace est alloué à la demande),
qui s’agrandit au fur et à mesure de la lecture des données.
Une liste est constituée de cellules chainées.
Une cellule est au moins composée de deux champs :
- un champ contenant un élément de la liste.
- un pointeur sur une autre cellule.
tête

5 18 20 Nil

Remarques :
Les cellules ne sont pas rangées séquentiellement en mémoire, d’une exécution à
une autre, leur localisation peut changer.
Une position est un pointeur sur cellule.
Rajouter ou supprimer un élément ne nécessite pas un décalage.
On doit à tout moment avoir un pointeur sur le début de la liste (la tête de la
liste).
La liste vide correspond au pointeur ayant une valeur d’adresse noté Nil.
2-Déclaration
Pour déclarer une liste chainée on utilise la syntaxe suivante :
Type

liste=^nœud ;
nœud=enregistrement
elt1 :<type_elt1> ;
svt :liste ;
fin enreg ;
var
p,q :liste ;
Exemple : déclarer une liste d’entiers
Type
Lent=^ent
ent=enregistrement
info : entier ;
suivant : Lent ;
fin enreg ;
var
T, p,q :Lent ;

Remarque :
- on peut avoir un ou plusieurs champs informations, et un ou plusieurs champs
pointeurs.
3-Acces aux valeurs d’une liste :
Considérons l’exemple
Exemple :
Type
liste =^nœud
nœud=enegistrement
valeur :entier ;
svt :liste ;
fin enreg ;
var
p :liste ;
pour accéder aux deux champs de la liste on utilise la syntaxe
p^.valeur ou pvaleur
p^.svt ou psvt

4-Creation d’un élément


Type
liste =^elt ;
elt=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete :liste ;
debut
Allouer(tete) ;
lire(tete^.val) ; /*lire (teteval) ;*/
tete^.svtNil ; /* tetesvtNil; */
fin. tete @
@ 15 Nil

5-creation d’une liste à 3 éléments


Type
liste =^elt
elt=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete,p,q :liste ;
debut
Allouer(tete) ;
lire(tete^.val) ;
tete^.svtNil ;
Allouer(p) ;
lire(p^.val) ;
p^.svtNil ;
tete^.svtp;
Allouer(q);
lire(q^.val) ;
q^.svtNil ;
p^.svtq ;
pNil ;
qNil ;
fin.
tete @1 p Nil q Nil

@1 val svt @2 @3
40 @2 3 @3 18 Nil

Remarque : on a fait le déroulement ensemble en ligne sur les variables


pointeurs et les cellules qu’elles pointent. Et ce qui est affiché c’est le
résultat final.
6-Creation de liste à N éléments(de gauche à droite)
Algorithme creation_liste ;
Type
liste =^element
element=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete,p,q :liste ;
i,N : entier ;
debut
repeter lire(N) ; jusqu’à N>0 ;
Allouer(tete) ;
lire(tete^.val) ;
tete^.svtNil ; qtete ; i1;
tantque i<N faire
Allouer(p);
lire(p^.val);
p^.svtNil ;
q^.svtp ;
qp ;ii+1 ;
fait ;
pNil ; qNil ;
fin.
tete q p N=4 i=4
@1 Nil Nil

@1 @2 @3 @4
14 @2 7 @K 26 @4 13 Nil
7-Affichage des éléments d’une liste
Algorithme Affichage ;
Type
liste =^element
element=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete,p,q :liste ;
debut
/* on suppose que la liste est créé */
ptete ;
Tantque p<>Nil faire
ecrire(p^.val) ;
pp^.suivant ;
fait ;
fin.
8-Liberer la liste :

debut
ptete ;
tantque tete<>Nil faire
tetetete^.svt ;
liberer(p) ; ptete;
fait;
fin.

9-Insertion d’une cellule à la position K


Algorithme insertion ;
Type
liste =^element
element=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
v,k,i :entier ;
Tete,p,q,q1:liste;
debut
/* liste déjà créer*/
lire(v) ;lire(k) ;
si k=1 alors
Allouer(p) ;
p^.valv ;
p^.svttete ;
tetep ;
pNil
sinon
ptete; i1;
tantque(p<>Nil) et (i<k) faire
qp ;pp^.svt ; ii+1 ;
fait;
Allouer(q1); q1^.valv;
q^.svtq1 ; q1^.svtp ;
fsi ;
pNil ; qNil ; q1Nil ;
fin.

10-Suppression d’une cellule (élément) à la position K :


Algorithme suppression ;
Type
liste=^element
element=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete,p,q :liste ;
i,k :entier;
debut /* liste créé*/
lire(k);
si k=1 alors
ptete ;
tetep^.svt ;
liberer(p) ;
pNil
sinon
ptete ; i1 ;
tantque(p^.svt<>Nil) et (i<k) faire
qp ;
pp^.svt ;
ii+1 ;
fait;
si i<>k alors
ecrire(‘suppression impossible’)
sinon
q^.svtp^.svt ;
liberer(p) ;
fsi ;
fsi ;
qNil ; pNil ;
Fin.
Exercice
Vérifier si une liste d’entiers est triée dans l’ordre croissant.
Algorithme verification ;
Type
Liste=^elt
elt=enregistrement
val :entier ;
svt :liste ;
fin enreg ;
var
tete, p :liste ;
debut
ptete;
tantque (p^.svt<>Nil) et (p^.val<=(p^.svt)^.val)
pp^.svt ;
fait ;
si p^.svt=Nil alors
ecrire (‘ liste triée’)
sinon
ecrire(‘liste non triée’) ;
fsi ;
pNil ;
fin.
11 Les listes bidirectionnelles
La liste est bidirectionnelle si on peut la parcourir dans les deux sens.
Exemple
liste=^elt ;
elt=enregistrement
val :entier ;
svt :liste ;
prec :liste ;
fin enreg ;
tete
@1
@1 @2 @3
val 1 2 3
svt @2 @3 Nil
prec Nil @1 @2

12-Les listes circulaires


La déclaration d’une liste circulaire suit le même schéma que la liste simple
(non circulaire) sauf que le dernier élément t pointe sur le premier élément (on a
pas de valeur Nil).
13-Les listes bidirectionnelles circulaires

Vous aimerez peut-être aussi