Les Listes lc1

Algorithmique et structure de données 3 Univ Batna-2- Chapitre3 : Les Listes linéaires chainées
1- Introduction :
Une structure séquentielle est un ensemble de variables de même nature organisées

séquentiellement auxquelles on peut accéder :
• Soit directement par leur numéro d’ordre.
Soit en les parcourant une par une dans l’ordre.
2- Listes Linéaires Chaînées (LLC)

2.1. Définitions : Une Liste Linéaire Chaînées (LLC) est un ensemble de maillons reliés entre eux.
Un maillon est une entité renfermant de l’information et ayant un pointeur sur le maillon qui la
suit. C’est toujours une structure (enregistrement) avec deux champs :
• un champ val : contenant la valeur ou l'information

• un champ suiv : donnant l'adresse du prochain maillon.
Une LLC est caractérisée par :
• L'adresse de son premier élément (la tête de liste). Elle doit toujours être sauvegardée dans
une variable pour pouvoir manipuler la liste.
• NIL constitue l'adresse qui ne pointe aucun maillon (indiquant par convention la fin de la
liste).
• Si la liste est vide (ne contient aucun maillon), la tête doit alors être positionnée à NIL.
1
Où typeqq est un type simple (entier, réel, caractère, ...) ou composé (tableau, chaîne de caractère,
structure, …..).
On définit un ensemble d'opérations que l'on va utiliser pour écrire des algorithmes sur les
listes. Cet ensemble d'opérations s'appelle le Modèle des Listes Linéaires Chaînées (MLLC) :
2
Voici l’équivalence en langage C, des fonctions et des procédures du modèle :
2-2. ALGORITHMES SUR LES LLCS
a/ Parcours :
Accès par valeur : il s'agit de rechercher (séquentiellement à partir de la tête) une valeur v dans la
liste.
Accès par position : il s'agit de rechercher (séquentiellement à partir de la tête) le maillon (son
adresse) qui se trouve à une position donnée. La position est le numéro d'ordre du maillon dans la
liste (entier).
b/ Mises à jour :
• Construction d'une liste à partir de n valeurs données.

• Insertion d'une valeur (v) à une position donnée (i) : allouer un nouveau maillon contenant v
et l'insérer dans la liste de telle sorte qu'il se retrouve à la i ème position.
• Insertion d'une valeur (v) dans une liste ordonnée : allouer un nouveau maillon contenant v
et l'insérer dans la liste de telle sorte que la liste reste ordonnée après l'insertion.
• Suppression du maillon se trouvant à une position donnée : rechercher par position le
maillon et le libérer.
• Suppression d'une valeur v dans la liste : rechercher par valeur et supprimer le maillon
trouvé en mettant à jour le précédent (s'il existe). Si la liste contient plusieurs occurrences
de la même valeur, on pourra les supprimer en faisant un seul parcours de la liste.
• Destruction de tous les maillons d'une liste.
c/ Tri sur les LLC :
Les mêmes algorithmes de tri utilisable pour les tableaux, en prenant en compte que l'accès par
position coûte beaucoup plus cher que dans un tableau.
d/ Fusion (ou Interclassement) de deux listes ordonnées : à partir de 2 listes ordonnées,

construire une liste ordonnée contenant tous leurs éléments (sans allouer de nouveaux maillons).
3
c/ Eclatement d'une liste en 2 listes distinctes : à partir d'une liste L et d'un critère (un prédicat)
donné, on construit deux listes, l'une contenant toutes les valeurs de L vérifiant le critère, l'autre,
celles qui ne le vérifient pas
3- Les opérations sur les LLCs :
3-1.Impression : Soient la liste suivante:
Procédure ImprimerLLC (L: ptrM)

Début
Tant que (L≠nil) faire // la liste n’est pas vide
DTQ
écrire (valeur (L)) ;
L ←suivant (L) ;
FTQ
Fin
La liste imprimée est 2, 10, 5, -1 et 6
3-2. Longueur d’une LLC : Soient la liste suivante:
Fonction LongLLC (L: ptrM): entier

Début
Cpt 0;
DTQ
Cpt ++ ;
L ←suivant (L) ;
FTQ
Retourner (Cpt) ;
Fin
La longueur de cette liste = 5
3-3. Recherche d’un élément dans LLc :
Fonction RechLLC (L: ptrM, v:entier): ptrM

Début
Si (valeur (L) = v) alors
retourner (L) ;
4
Sinon
L ← suivant (L) ;
FTQ
Retourner (nil) ;
Fin
Si v= 1 alors la fonction retourne nil.

- Rechercher le maillon qui se trouve à la position k = 4.
Fonction RechPosLLC (L: ptrM, K: entier positif): ptrM

Debut
Si K > 0 alors
i ←1
Tant que (i<K) et (L≠nil) faire //accéder au K ème maillon
DTQ
i++; L ←suivant (L);
FTQ
Retourner (L);
Sinon
Retourner (nil) ;
Fin
- Si k= 6, le maillon n’existe même pas (retourner nil)
3-4. Insertion d’un élément dans LLC
Pour ajouter un élément dans la liste, il y a plusieurs situations :
1. Insertion au début de la liste
2. Insertion à la fin de la liste
3. Insertion à une position donnée
Cas 1: Insertion au début
Procédure InsererLLC_Deb(Var L: ptrM, v:entier)

Début
P = allouer () ;
aff_val(P, v) ;
aff_suiv(P, L) ;
L←P ; //mettre à jour la tête de la liste
Fin
5
Cas 2: Insertion à la fin
Procédure InsererLLC_Fin (Var L: ptrM, v:entier)

Début
P = allouer (); aff_val(P, v); aff_suiv(P, nil) ;
Si (L=nil) alors //la liste est vide
L ←P ; // mettre à jour l’entête
Sinon
Dsinon
Q ←L ;
Tant que (suivant (Q)≠nil) faire // accéder au dernier maillon
Q ←suivant (Q) ; aff_suiv (Q, P) ;
Fsinon
Fin
Cas 3: Insertion à une position donné « k ».
Si k = 1 alors insérer le maillon au début
Sinon, accéder d’abord au maillon de position « k -1 », ensuite refaire le chaînage comme suit;
Procédure InsererLLC_pos (Var L: ptrM, k: entier positif, v:entier, Var possible: booléen)
Debut
possible← faux ;
Si (k>0) alors
Si (k=1) alors
InsererLLC_Deb(L, v)
possible ←vrai
Sinon
Q ← RechPosLLC(L, k-1) ;
Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe
P = allouer (); aff_val(P, v) ;
aff_suiv (P, suivant (Q)) ;
6
aff_suiv (Q, P) ; possible ←

vrai ;
FSi
Fsi
Fnsi
Fin
4- Création d’une LLc : Pour créer une liste:
1. Allouer un nouveau maillon
2. Initialiser le maillon avec la valeur lue
3. Insérer dans la liste. On distingue deux cas:
a. Insertion à la fin
b. Insertion au début et la liste crée est inversée
Cas 1: Insertion à la fin : Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6
Procédure CreerLLC (Var L: ptrM) Procédure CreerLLC (Var L: ptrM)

Début Début
Pour i←1 à N faire Pour i←1 à N faire
DP DP
lire (x) ; lire (v) ;
P = allouer () ; InsererLLC_Fin(L, v) ;
aff_val(P, x) ; FP
aff_suiv(P, nil) ; Fin
Sinon
aff_suiv(Q, P) ;
Q←P ; //sauvegarder l’@ du dernier maillon
FP
Fin
7
Cas 2: Insertion au début
Procédure CreerLLC_inverse (Var L: ptrM) Procédure CreerLLC_inverse (Var L: ptrM)

Début Début
Pour i←1 à N faire Pour i←1 à N faire
DP lire (v) ;
lire (x) ; InsérerLLC_Deb( L, v) ;
P = allouer () ; Fp
aff_val(P, x) ; Fin
aff_suiv(P, L) ;
L←P ; //mettre à jour la tête de la list
FP
FIN
5-inverse d’une LLC :
Procédure InverserLLC (Var L: ptrM)

Début
P ← Nil ;
TQ (L≠Nil) faire
Q ←L ;
L←suivant (L) ;
aff_suiv(Q, P) ;
P←Q ;
FQ
L← P ;
Fin
8
6- SUPPRESSION un élément dans LLc:
Pour supprimer un maillon contenant la valeur v, il faut d’abord rechercher ce maillon. Une fois
trouvé (soit P ce maillon), on va refaire le chaînage (son précédent avec son suivant), ensuite,
libérer le maillon P.
Procédure SuppLLC (Var L:ptrM, v:entier)

Début
P←L; Q←nil ;
TQ ((P ≠ nil) et (valeur (P) ≠ v) ) /* rechercher le premier maillon contenant v*/
Q←P; P ←suivant (P) ;
FTQ
Si (P ≠ nil) alors
Si Q = nil alors /* Suppression du premier maillon */
L ← suivant (P);
Sinon
aff_suiv(Q,suivant (P));
Fsi
Fsi
libérer (P) ;
Fin
- Suppression de tous les maillons contenant la valeur v
Procédure SuppTousLLC (Var L:ptrM, v:entier)

Début
P←L; Q←nil ;
TQ (P ≠ nil)
Si (valeur (P) ≠ v)
Q←P; P ←suivant (P) ;
Sinon
9
Si Q = nil alors
L ← suivant (P); Libérer (P); P←L;
Sinon
aff_suiv(Q,suivant (P)); libérer (P); P←suivant (Q);
Fin
Suppression à une position donnée « k ». Deux

situations se présentent :
• k = 1, supprimer le premier maillon

• k ≠ 1, accéder d’abord au maillon de position « k-1», sauvegarder l’adresse du maillon «
k+1 », ensuite refaire le chaînage comme suit ;
Procédure SuppPosLLC (Var L:ptrM, k:entier positif, Var possible : booléen)

Début
Possible ←faux ;
Si (k>0) alors
Si (k = 1) alors // supprimer le premier maillon
P←L; L ← suivant (L); libérer (P);
Possible← vrai ;
Sinon
Q←RechPosLLC(L, k-1) ;
Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe
P←suivant (Q); aff_suiv(Q,suivant (P)); libérer (P);
Possible ←vrai
Fin
7- DESTRUCTION d’une LLC
Soient la liste suivante :
10
Procédure DetruireLLC (Var L:ptrM)

Début
DTQ
P←L ;
L ←suivant (L) ;
libérer (P) ;
FTQ
Fin
8- LISTES PARTICULIÈRES
8.1- LISTE CIRCULAIRE : Liste circulaire est une LLC où le dernier maillon pointe le
premier, formant ainsi un cercle.
La tête de la liste est l'adresse de n'importe quel maillon.
Le même modèle des LLC est utilisé pour écrire des algorithmes sur ce type de listes:
MLLCcir = MLLC
8-2. Liste Circulaire (Quelques Algorithmes) a/-

Impression d’une LLC circulaire
Procédure ImprimerLLCcir (L:ptrM)

Début
Si L ≠ nil alors
P←L ;
Répéter
Écrire (valeur (P)) ;
P ←suivant(P) ;
Jusqu’à P=L
Fin
11
b/ -Recherche le premier maillon contenant la valeur v
Fonction RechLLC_cir (L:ptrM, v:entier): ptrM

Début
Si L ≠ nil alors
P←L ;
Répéter
Si (valeur (P) = v) alors
retourner (P) ;
P ←suivant(P) ;
Jusqu’à P=L
Retourner (nil) ;
Fin
c/- Insertion dans une LLC circulaire
Procédure InsLLCcir (Var L:ptrM, v:entier)

Début
P = allouer() ;
aff_val(P, v) ;
aff_suiv(P, P) ;
Sinon
aff_suiv(P , suivant (L)) ;
aff_suiv (L, P) ;
Fin
8.3- Construction d’une LLC circulaire :
Construire une LLC unidirectionnel a la fin, chaîner le dernier maillon avec le premier
12
Procédure CreerLLCcir (Var L:ptrM, N:entier)

Début
Pour i←1 à N faire
lire (x) ;
P = allouer (); aff_val(P, x) ;
Si (L=nil) alors L ←P ; // mettre à jour l’entête
Sinon aff_suiv(Q, P) ;
Q←P ; //sauvegarder l’@ du dernier maillon aff_suiv (P, L);
Fp
Fin
Construction d’une LLC circulaire 2eme méthode
2 éme Méthode
Procédure CreerLLCcir (Var L:ptrM, N:entier)
Début
lire (x); P = allouer (); aff_val(P, x) ;
Sinon
aff_suiv(Q, P) ;
aff_suiv(P, L) ;// lier le dernier maillon au premier
Q←P ;//sauvegarder l’@ du dernier maillon
Fp
Fin
13
8.4- Suppression du maillon contenant la valeur v
Rechercher le maillon contenant la valeur v S’il existe un tel maillon, on distingue deux cas :
1. La valeur se trouve dans le maillon « L »,
a. Si la liste contient qu’un seul maillon, alors la liste devient vide
b. Sinon, mettre à jour le pointeur L et refaire le chaînage.
2. La valeur se trouve dans un autre maillon (≠ L), refaire le chaînage
Procédure SuppLLCcir (L:*maillon, v:entier)

Début
Si (L ≠ nil) alors // la liste n’est pas vide
P←L ;
répéter
Q←P ;
P ←suivant (P) ;
jusqu’à (P = L) ou (valeur (P) =v ) //rechercher le maillon contenant la valeur v
Si valeur (P) =v alors // il existe un maillon contenant la valeur v
Si P = L alors //la valeur se trouve dans le maillon L
Si P = Q alors // la liste contient un seul maillon
L ← nil
Sinon
L ← suivant (P); aff_suiv(Q,suivant (P)) ;
Sinon
aff_suiv(Q,suivant (P)) ;
libérer (P) ;
Fin
8-5. Destruction d’une LLC circulaire
Procédure DetruireLLCcir (L:*maillon)

Début
Si L≠nil alors
P ←suivant (L) ;
TQ (P≠L) faire
aff_suiv(L, suivant (P)) ;
libérer (P) ;
P ←suivant (L) ;
FTQ
14
Libérer (P);
L ←nil;
Fsi
Fin
9-Liste Bidirectionnelle (Doublement Chaînées):
9-1. Définition :
• Liste bidirectionnelle ou Liste Doublement Chaînées est une liste que l'on peut parcourir
dans les deux sens : de gauche à droite (pour aller au maillon suivant) et de droite à gauche
(pour aller au maillon précédent).
• Elle est définit par sa tête, aussi que par sa queue.
Chaque maillon d’une liste bidirectionnelle comporte trois champs :
Un champ contenant la donnée.
Un pointeur vers l'élément suivant de la liste.
Un pointeur vers l'élément précédent de la liste.
Le modèle des LLC bidirectionnelles est donc étendu par les opérations suivantes :
MLLCbd = MLLC + { Init, Aff_prec, Précédent }.
15
9-2. Impression d’une LLC Bidirectionnelle
Procédure ImprimerLLCbd (Var L: ListeBD)

Début
T←L.Tete ;
Tant que (T≠nil) faire // la liste n’est pas vide
écrire (valeur (T)) ;
T ←suivant (T) ;
Fin
- La liste imprimée est 2, 5, -1, 6.
Procédure ImprimerLLCbd_inverse(Var L: ListeBD

Début
Q ← L.Queue ;
Tant que (Q≠nil) faire // la liste n’est pas vide
écrire (valeur (Q)) ;
Q ←precedent (Q) ;
Fin
- La liste imprimée est 6, -1, 5, 2.
9-3. Recherche d’une valeur dans une LLC Bidirectionnelle :
Algoritgme 1 : Recherche d’une valeur dans une LLC Bidirectionnelle
Fonction RechLLCbd(L: ListeBD, v:entier): ptrMBD

Début
P ←L.Tete ;
Tant que (P≠nil) faire // la liste n’est pas vide
Si valeur (P) = v alors retourner (P) ;
Sinon P ←suivant (P) ;
Ftq
16
Retourner (nil) ;
Fin
Algoritgme 2 : Recherche d’une valeur dans une LLC Bidirectionnelle
Fonction RechLLCbd (L: ListeBD, v:entier): ptrMBD

Début
P ←L.Queue ;
Tant que (P≠nil) faire // la liste n’est pas vide
Si valeur (P) = v alors retourner (P) ;
Sinon P ←précédent (P) ;
Ftq
Retourner (nil) ;
Fin
9-4. Recherche du maillon qui se trouve à une position donnée
RechLLCbd_pos(L: ListeBD, K: entier positif): ptrMBD

Debut
P ←L.Tete; i ←1;
Tant que( (i<K) et (P≠nil)) faire //accéder au K ème maillon
DTQ
i++;
P ←suivant (P);
FTQ
Retourner (P);
Fin
9-5. Insertion au début de la liste
Procédure InsererLLCbd_Deb (Var L: ListeBD, v:entier)

Début
P = Allouer ();
aff_val(P, v);
Si L.Tete = nil alors // si la liste est vide
aff_suiv(P, nil); aff_prec(P, nil);
L.Tete ←P;
17
L.Queue ←P;
Sinon
aff_prec (P, nil);
aff_suiv (P, L.Tete) ;
aff_prec (L.Tete, P);
L.Tete←P //mettre à jour la tête
Fin
9-6. Insertion à la fin de la liste.
Procédure InsererLLCbd_Fin (Var L: ListeBD, v:entier)

Début
P = Allouer ();
aff_val(P, v);
Si L.Queue = nil /la liste est vide
aff_suiv(P, nil);
aff_prec(P, nil);
L.Tete ←P;
L.Queue ←P; Sinon
aff_suiv(P, nil) ;
aff_suiv (L.Queue, P);
aff_prec (P, L.Queue) ;
L.Queue←P ; //mettre à jour la queue Fin
9-7. Insertion à une position donnée
Procédure InsererLLCbd_pos (Var L: ListeBD, v:entier, K:entier positif)

Debut
Si (K>0 )alors
Si (K = 1) alors InsererLLCbd_Deb(L, v) ;
Sinon
S← RechLLCbd_pos(L, K):;
Si (S ≠ Nil) alors
18
P = Allouer (); aff_val(P, v);

aff_suiv (Precedent (S), P) ;
aff_prec (P, Precedent (S));
aff_suiv (P, S) ;
aff_prec (S, P) ;
Fin
9-8. Construction d’une LLC Bidirectionnelle
- Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6.
Procédure CreerLLCbd (Var L: ListeBD)

Début
Init (L) ;
lire (x);
InsererLLCbd_Fin (L, x);
Fp
Fin
9-8. Construction d’une LLC Bidirectionnelle inversée
- Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6.
Procédure CreerLLCbd_inverse(Var L: ListeBD)

Début
Init (L) ;
lire (x);
InsererLLCbd_Deb (L, x);
Fp
Fin
19
9-9. Destruction d’une LLC Bidirectionnelle
Procédure DetruireLLCbd (Var L: ListeBD) Procédure DetruireLLCbd (Var L: ListeBD)

Début Début
T←L.Tete ; Q←L.Queue ;
Tant que (T≠nil) faire Tant que (Q≠nil) faire
P←T ; P←Q;
T ←suivant (T) ; Q ←precedent (Q);
libérer (P) ; libérer (P) ;
FTq FTq
Init (L); Init (L);
Fin Fin
10 LISTE BIDIRECTIONNELLE CIRCULAIRE :
Définition : Liste bidirectionnelle circulaire est une LLC à double sens et dont le dernier maillon
pointe sur le premier maillon et le premier maillon pointe sur le dernier maillon.
- Le même modèle des LLCs bidirectionnel est utilisé pour écrire des algorithmes sur ce type
de liste : MLLCbdcir = MLLCbd.
Conclusion :
• L’inconvénient des listes chainées réside dans l’accès séquentiel à leurs éléments.
• En effet, pour accéder à un élément, il faut passer par tous les éléments qui le précèdent =>
augmentation du temps de calcul.
Afin de pallier ce problème, une autre structure de donnée peut être utilisée, il s’agit de la structure
ARBRE.
20

Les Listes lc1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Les Listes lc1

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique et structure de données 3 Univ Batna-2- Chapitre3 : Les Listes linéaires chainées

Une structure séquentielle est un ensemble de variables de même nature organisées

• Soit directement par leur numéro d’ordre.

Soit en les parcourant une par une dans l’ordre.

2- Listes Linéaires Chaînées (LLC)

• un champ val : contenant la valeur ou l'information

Une LLC est caractérisée par :

2-2. ALGORITHMES SUR LES LLCS

• Construction d'une liste à partir de n valeurs données.

c/ Tri sur les LLC :

d/ Fusion (ou Interclassement) de deux listes ordonnées : à partir de 2 listes ordonnées,

3- Les opérations sur les LLCs :

3-1.Impression : Soient la liste suivante:

Procédure ImprimerLLC (L: ptrM)

Fonction LongLLC (L: ptrM): entier

3-3. Recherche d’un élément dans LLc :

Fonction RechLLC (L: ptrM, v:entier): ptrM

Si v= 1 alors la fonction retourne nil.

Fonction RechPosLLC (L: ptrM, K: entier positif): ptrM

1. Insertion au début de la liste

2. Insertion à la fin de la liste

3. Insertion à une position donnée

Cas 1: Insertion au début

Procédure InsererLLC_Deb(Var L: ptrM, v:entier)

Procédure InsererLLC_Fin (Var L: ptrM, v:entier)

Si k = 1 alors insérer le maillon au début

aff_suiv (Q, P) ; possible ←

4- Création d’une LLc : Pour créer une liste:

1. Allouer un nouveau maillon

2. Initialiser le maillon avec la valeur lue

3. Insérer dans la liste. On distingue deux cas:

b. Insertion au début et la liste crée est inversée

Cas 1: Insertion à la fin : Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6

Procédure CreerLLC (Var L: ptrM) Procédure CreerLLC (Var L: ptrM)

Procédure CreerLLC_inverse (Var L: ptrM) Procédure CreerLLC_inverse (Var L: ptrM)

5-inverse d’une LLC :

Procédure InverserLLC (Var L: ptrM)

Procédure SuppLLC (Var L:ptrM, v:entier)

Procédure SuppTousLLC (Var L:ptrM, v:entier)

Suppression à une position donnée « k ». Deux

• k = 1, supprimer le premier maillon

Procédure SuppPosLLC (Var L:ptrM, k:entier positif, Var possible : booléen)

7- DESTRUCTION d’une LLC

Soient la liste suivante :

Procédure DetruireLLC (Var L:ptrM)

La tête de la liste est l'adresse de n'importe quel maillon.

8-2. Liste Circulaire (Quelques Algorithmes) a/-

Procédure ImprimerLLCcir (L:ptrM)

b/ -Recherche le premier maillon contenant la valeur v

Fonction RechLLC_cir (L:ptrM, v:entier): ptrM

c/- Insertion dans une LLC circulaire

Procédure InsLLCcir (Var L:ptrM, v:entier)

8.3- Construction d’une LLC circulaire :

Procédure CreerLLCcir (Var L:ptrM, N:entier)

Construction d’une LLC circulaire 2eme méthode

Procédure SuppLLCcir (L:*maillon, v:entier)

8-5. Destruction d’une LLC circulaire

Procédure DetruireLLCcir (L:*maillon)

9-Liste Bidirectionnelle (Doublement Chaînées):

Chaque maillon d’une liste bidirectionnelle comporte trois champs :

Un champ contenant la donnée.

Un pointeur vers l'élément suivant de la liste.

Un pointeur vers l'élément précédent de la liste.