Chapitre 3

Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données
CH3 : Les listes
1. Définition d’une liste :

Une liste est un ensemble fini d’éléments ordonnés, chaque élément contient un ou plusieurs champs.
Le premier élément de la liste est appelé « Tête ».
Le dernier élément est appelé « Queue »
Chaque élément possède un successeur sauf la queue (son successeur est la valeur NULL).
5 2 -25 7 ...... 2
Tête Eléme Queue

nt
La notation linéaire [5, 2, -25, 7, ..., 2] représentera la liste qui contient cette séquence.
Les structures de données linéaires induisent une notion de séquence entre les éléments (1er, 2ème, 3ème, suivant, dernier, …).
2. Operations sur les listes :

On distingue deux sortes d’opérations sur les listes :
• Les opérations qui concernent les éléments de la liste
• Les opérations concernant la liste elle-même.
2.1. Les opérations sur « les éléments » de la liste :

Insérer un élément (la 1ere place, en queue, au milieu)
Supprimer un élément (le 1er élément, le dernier élément, un élément au milieu)
Rechercher un élément afin d’afficher le contenue ou le modifier.
2.2. Operations globales sur la liste elle-même :
En plus des opérations vues précédemment, d’autres peuvent être s’effectuent sur la liste elle-même tels que :
Tester si la liste est vide.

Création d’une liste.
Vider une liste.
Calculer le nombre d’éléments dans une liste.
Trier une liste.
Fusionner deux listes : consiste à regrouper 2 listes en une seule.
Eclatement d’une liste : consiste a diviser la liste originale en 2 sous listes.
Etc...
3. Représentation des listes :

Il existe plusieurs méthodes pour implémenter des listes. Les plus courantes sont l’utilisation des tableaux (représentation
contiguë) et de pointeurs (représentation chainée).
3.1. La représentation contiguë (Tableau):

Les éléments de la liste sont simplement rangés dans le tableau à leur place respective séquentiellement (les uns à la suite
des autres).
M. bada 1
a) Inconvénients
L’utilisation de tableaux possède quelques inconvénients :
! PBM1 : La dimension d’un tableau doit être définie lors des déclarations et ne peut donc pas être
modifié
o Solution : définir un tableau dont la taille sera suffisante pour accueillir le plus grand nombre
d’éléments
" PBM2 : gaspillage d’espace mémoire au cas des petites listes.
" PBM3 : si la taille maximum venait à être augmentée # il faudrait modifier le
programme et le recompiler
! Lorsqu’on veut retirer (ou insérer) un élément du tableau « en début », il est nécessaire de décaler tous
les éléments situés après l’élément supprimé.
b) Avantages :
! L’accès au Keme element est immédiate : T[K]

! Trouver le suivant d’un élément : T[K+1]
3.2. La représentation chainée (utilisation des pointeurs) :
Une liste chaînée est une structure linéaire qui n'a pas de dimension fixée à sa création.
Ses éléments de même type sont dispersés dans la mémoire et reliés entre eux par des pointeurs.
• Un élément ou maillon d’une liste est toujours une structure (Objet composé) avec deux ou plusieurs
champs :
o Un ou plusieurs champ = Valeur : contenant l’information
o Un champ = Adresse : donnant l’adresse du prochain élément.
La liste est accessible uniquement par sa tête de liste c’est-à-dire son premier élément.
3.2.1. Structure d’un élément : Un élément de la liste est une structure de donnée définie comme suite :
Langage C Pascal (langage algorithmique)
struct element Type element = record

{
type1 Champ_1; Champ_1 : Type1 ;
.... ....
typeN Champ_N; Champ_N : TypeN ;
element* Suivant ; Suivant : ^element ;

} End ;
M. bada 2
Apres la déclaration de la structure élément, on peut créer des élément dynamiques en utilisant les pointeurs :
element* e ; Var e : ^element ; Var e : ↑element ;

e = (element*) malloc (sizeof(element)) ; .... ....
new (e) ; allouer (e) ;
Le résultat d’exécution de ce bloc d’instructions est le suivant :
(*e).champ1 (*e).suivant
ou ou
e->champ1 e->suivant
e
#100
Champ1 ... ChampN Suivant

*e
3.2.2. C’est quoi une liste exactement ? :
La déclaration d’un tableau T de N éléments en C mène à la création de N+1 variables : T[0], T[1], ...,T[N-1] et T.
# T : un pointeur (adresse) de la première case.
En quelque sorte, on peut dire que le tableau dans un programme n’est que l’adresse de la 1ere case = &T[0].
Comme pour les tableaux, une liste n’est que l’adresse du premier élément (Tête) de la liste.
a) Liste vide :
Une liste est dite vide si elle ne contient aucun élément. En d’autre terme, une liste vide est un pointeur qui
est égale à NULL.
Liste
Element* Liste ;
Liste =NULL ;
NULL
M. bada 3
4. Operations sur les listes chainées (langage C) :
4.1. Parcourir une liste :
Comme pour les tableaux, afin de parcourir une liste on a besoin de passer par touts les éléments en utilisant un index
(compteur ou position).
Pour afficher ou modifier le contenu d'un élément dans une liste chainée, l’index doit se pointer vers cet élément. Pour
cela il faut trouver un moyen qui permet de déplacer l’index d’un élément vers l’élément suivant.
Ex :
Un étudiant est définie par les champs suivant : N, Nom
Supposons qu’on a une liste d’étudiants déjà créée, dont la queue pointe vers null.
#100
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
#100 #50 #200
a) Analogie avec les tableaux :
Tableau Liste chainée
Etudiant T [N] ; Etudiant* liste ;

Déclaration d’une
liste vide
Création .... Voir la section ....
Int i ; Etudiant* position ;

Déclaration d’un
compteur (index=
position)
i=0 ; Position = liste ;

Initialisation du
compteur
While (i<N) While (position != NULL)

Condition d’arrêt { {
Printf ("%d", T[i].N) ; Printf ("%d", (*position).N) ;

Afficher le numéro
i=i+1 ; Position = (*position).suivant ;

Incrémentation } }
I=N Position= NULL

Valeur du
compteur a la fin
M. bada 4
Etape1 : initialisation # position= Lise = #100;
Liste Position
#100 #100
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
*position
#50 #200
(*position).suivant
Etape2 #la boucle while : 1ere incrémentation # position = (*position).suivant = #50;
Liste Position
#100 #50
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
*position
#50 #200
(*position).suivant
Etape3 # la boucle while :2eme incrémentation # position = (*position).suivant = #200;
Position
Liste
#50
#100
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
#100 #50 #200
M. bada 5
Etape4 # la boucle while : 3eme incrémentation (dernière) # position = (*position).suivant = NULL;
Position
Liste
NULL
#100
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
#100 #50 #200
NB : A la fin de cette boucle le pointeur position = NULL.
4.2. Insérer un élément :
4.2.1. Insérer un élément à la fin de liste :

Insérer un élément à la fin de la liste consiste à modifier le champ « suivant » de la queue, et mettre à la place de la
valeur NULL l’adresse du nouvel élément que l’on veut insérer.
Liste
#100
3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL
#100 #50 #200
#700
10 ‘’NV’’ NULL
Liste
Position
#100
#200
2 ‘’...’’ #700
3 ‘’aa’’ #50 6 ‘’...’’ #200
#100 #50 #200
e
#700
10 ‘’NV’’ NULL
M. bada 6
Pour insérer un élément à la fin il faut suivre les étapes suivantes :
Etape1 : création dynamique d’un nouvel élément (utilisation des pointeurs)
Etudiant* e ;
e= (Etudiant*) = malloc (sizeof (Etudiant) ) ;
Etape2 : initialisation de l’élément (lecture a partir d’un clavier) :
scanf ("%d", & (*e).N ) ;

scanf ("%s", & (*e).Nom) ;
(*e).suivant = NULL ;
Etape 3 : parcourir la liste jusqu'à le dernier élément (position -> pointe le dernier élément « la
Queue » et pas NULL !!! ) # donc il faut faire avancer le pointeur position jusqu'à que son suivant
= NULL.
Etudiant* position ;
position= liste ;
while ( (*position).suivant != NULL )
{
position = (*position).suivant ;
}
Etape 4 : établir la liaison entre la liste et le nouvel élément
(*position).suivant = e ;
4.2.2. Insertion en tête de la liste
Liste
#700
2 ‘’...’’ NULL
3 ‘’aa’’ #50 6 ‘’...’’ #200
2
#100 #50 #200
e 1
#700
10 ‘’NV’’ #100
*e
M. bada 7
Etape1 : création dynamique d’un nouvel élément (utilisation des pointeurs) + initialisation :
Etudiant* e ;
scanf ("%d", & (*e).N ) ;

scanf ("%s", & (*e).Nom) ;
Etape 2 : établir la 1ere liaison N1 dans le schéma.
(*e).suivant = liste ;
Etape 3 : établir la 2eme liaison N2 dans le schéma.
Liste = e ;
4.2.3. Insertion au milieu :
Il existe plusieurs façons de savoir l’endroit d’insertion d’un élément :
Directe : dans ce cas on va utiliser directement une variable « place » qui donne la position où l’on doit
insérer le nouvel élément.
Indirecte : dans ce cas, il faut trouver un élément particulier « ex : l’étudiant Mohammed » à partir du
quel on déterminera la position du nouvel élément : (avant ou après).
Cas1 : insertion directe:

Pour insérer un élément à un endroit (K) de la liste, il est nécessaire d’abord de se positionner sur l’élément qui
vient juste avant le nouvel élément pour qu’on puisse établir la liaison entre la 1ere partie de la liste et le nouvel
élément.
Etape1 : création dynamique d’un nouvel élément (utilisation des pointeurs) + initialisation
Etudiant* e ;
scanf ("%d", & (*e).N ) ;

scanf ("%s", & (*e).Nom) ;
Etape 2 : parcourir la liste jusqu'à trouver l’élément qui se trouve à la place : K -1 :
Etudiant* position ;
position= liste ;
int i=0 ;
while ( i < K-2 )
{
position = (*position). suivant ;
i=i+1 ;
}
M. bada 8
Etape 3: établir la liaison N3 : entre le nouvel élément et la 2eme partie de la liste.
(*e).suivant = (*position).suivant ;
Etape 4: établir la liaison N4 : entre la 1ere partie de la liste et le nouvel élément
(*position).suivant = e ;
2
Position
E1 E2 E3 E4 E5 NULL
Tête
4 3
Créer (Nv Element) Nv E

Suivant (Nv Element) =E4 1
Suivant (E3) = Nv Element
Remarque : attention d’inverser les étapes 3 et 4, car ceci mène a perdre la 2eme partie de la liste
4.3. Suppression d’un élément :
4.3.1. Supprimer le 1er élément :

Il y a deux actions, dans cet ordre, à réaliser :
• faire pointer la tête de liste sur le deuxième élément de la liste.

• libérer l'espace mémoire occupé par l'élément supprimé.
Il est nécessaire de déclarer un pointeur local (P1) qui va pointer sur l'élément à supprimer, et permettre de libérer
l'espace qu'il occupait.
P1
E1 E2 E3 E4 E5 NULL
Liste Etudiant* P1 ;
P1= liste ;
Liste = (*liste).suivant ;
Free (P1) ;
M. bada 9
4.3.2. Supprimer le dernier élément (utilisation de deux pointeurs) :
P2 P1
E1 E2 E3 E4 E5 NULL
Tête
Etudiant* p1 ; // utilisé pour pointer le dernier élément

Etudiant* p2 ; // utilisé pour pointer l’avant dernier élément
P1= liste ;
P2= liste ;
while ( (*P1).suivant != NULL )

{
P2=P1 ; // sauvegarder l’ancienne valeur de P1
P1= (*P1).suivant ; // avancer P1 seulement
}
// A la fin de cette boucle P1 est toujours avancé d’un pas par rapport a P2.
(*P2).suivant = NULL ;
free (P1) ; // libérer l'espace
4.3.3. Supprimer un élément au milieu :
P2 P1
E1 E2 E3 E4 E5 NULL
Tête
M. bada 10
I=0 ;
while ( i < K-1 )
{
P2=P1 ; // sauvegarder l’ancienne valeur de P1
P1= (*P1).suivant ; // avancer P1 seulement
i = i+1 ;
}
// A la fin de cette boucle : P2 pointe vers l’élément précèdent
// A la fin de cette boucle : P1 pointe vers l’élément suivant
(*P2).suivant = (*P1).suivant;
free (P1) ; // libérer l'espace
4.4. La création d’une liste chainée :

Pour créer une liste chaînée, il existe 2 méthodes :
4.4.1. création en pile : (LIFO)

Création d’une liste en insérant les nouveaux éléments au début de la liste.
Ex : si on veut introduire les 3 étudiants dont les prénoms sont : « Atef» puis « Hacene » puis « Seif»
Le résultat est : [seif, hacene, atef]
On remarque que le dernier élément saisi est le premier élément de la liste : (Last In First Out).
etudiant* Tete=NULL; // au début la liste est vide

etudiant* E;
int bol=1;// une variable utiliser pour arrêter la saisie
do {
//allocation d’espace mémoire pour le nouvel élément
E= (etudiant*) malloc(sizeof(etudiant)) ;
//lire le N et le Nom
scanf ("%i",&(*E).N);
scanf ("%s",&(*E).nom);
// Insérer le nouvel élément au début de la liste

(*E).suivant=Tete;
Tete=E;
//poser la question a l’utilisateur : est ce que vous voulez insérer un autre élément ?
//bol=0 # non , bol = 1 # oui
scanf ("%i",&bol);
}while (bol==1); // refaire a boucle si l'utilisateur tape sur 1(oui).
M. bada 11
4.4.2. création en file : (FIFO) :

Création d’une liste en insérant les nouveaux éléments à la fin de la liste.
Ex : si on veut introduire les 3 étudiants dont les prénoms sont : « Atef» puis « Hacene » puis « Seif»
Le résultat est : [atef, hacene, seif]
On remarque que le premier élément saisi est le premier élément de la liste : (First In First Out).
Etape 0 : initialisation
Tête = derElement
NULL = NULL
Etape 1 : boucle # i =1 # Tete= NULL (cette étape s’exécute une seule fois)
derElement
E1 NULL
1:
Création
Tête 2 d’élément

Etape 2 : boucle (i= 2 , 3 ......N) # ici : i=2 # 2eme élément
derElement =
derElement = @ E1 (*derElement).suivant ;
=@ E2
5

E1 @E2 E2 NULL
4

1:
Création
Tête
d’élément

NB : La variable ( derElement ) pointe toujours le dernier élément.
M. bada 12
Etape 2 : boucle (i= 2 , 3 ......N) # ici : i =3 # 3eme élément :
derElement =
derElement = @ E2 (*derElement).suivant ;
=@ E3
5

E1 @E2 E2 @E3 E3 NULL
4
1:
Création
Tête d’élément

NB : La variable ( derElement ) pointe toujours le dernier élément.
Les étapes sous forme d’instructions :
etudiant* Tete=NULL; // au début la liste est vide

etudiant* derElement //pointe tjr le dernier élément.
int i ;
for (i =1 ; i<=N ; i++)
{
//allocation d’espace mémoire pour le nouvel élément

E= (etudiant*) malloc(sizeof(etudiant)) ;
1:
//lire le N et le Nom Création
d’élément
scanf ("%i",&(*E).N);

scanf ("%s",&(*E).nom);
(*E).suivant = NULL ;
si (tete == NULL){
// Ce bloc sera exécuté une seule fois (le 1 er élément)
tete = E ; 2+3
derElement= Tete ;
}else{
// A partir du 2eme élément
(*derElement).suivant = E ;
4+5
derElement=(*derElement).suivant ;
}
M. bada 13
5. Types de listes :
Il existe différents types de listes chaînées :
5.1. Liste chaînée simple constituée d'éléments reliés entre eux par des pointeurs (suivant).
5.2. Liste chaînée ordonnée : c’est une liste simplement chainée où l'élément suivant est plus grand que le précédent.
L'insertion et la suppression d'élément se font de façon à ce que la liste reste triée.
5.3. Liste doublement chaînée : c’est une liste où chaque élément dispose non plus d'un seul pointeur mais de deux
pointeurs pointant respectivement sur l'élément précédent et l'élément suivant. Ceci permet de lire la liste dans les
deux sens, du premier vers le dernier élément ou inversement.
Structure d’un élément : liste

doublement chainée
struct element
{
element* Precedent ;
type1 Champ_1;
....
typeN Champ_N;
element* Suivant ;
}
Le pointeur Précèdent du premier élément ainsi que le pointeur Suivant du dernier élément
contiennent la valeur Nil.
5.3.1. Parcourir une liste doublement chainée :

a) De la tête vers la queue :
Il est possible de parcourir la liste doublement chaînée du premier élément vers le dernier. Le pointeur de
parcours, P, est initialisé avec l'adresse contenue dans Tête.
Il prend les valeurs successives des pointeurs Suivant de chaque élément de la liste. Le parcours s'arrête
lorsque le pointeur de parcours a la valeur NULL Cet algorithme est analogue à celui du parcours d'une liste
simplement chaînée.
M. bada 14
b) De la queue vers la tête :

Il est possible de parcourir la liste doublement chaînée du dernier élément vers le premier. Le pointeur de
parcours, P, est initialisé avec l'adresse contenue dans Queue.
Il prend les valeurs successives des pointeurs Précédent de chaque élément de la liste. Le parcours s'arrête
lorsque le pointeur de parcours a la valeur NULL.
5.4. Liste circulaire : c’est une liste où le dernier élément pointe sur le premier élément de la liste.
5.5. Liste doublement chainée circulaire : il s'agit d'une liste doublement chaînée où : le dernier élément pointe le
1er élément et le premier élément pointe également sur le dernier.
Remarque : Ces différents types peuvent être mixés selon les besoins.
6. Inconvénients :
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 etre utilisée, il s’agit de la structure ARBRE (voir chapitre 5).
M. bada 15

Chapitre 3

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

Chapitre 3

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

CH3 : Les listes

1. Définition d’une liste :

Tête Eléme Queue

2. Operations sur les listes :

2.1. Les opérations sur « les éléments » de la liste :

2.2. Operations globales sur la liste elle-même :

Tester si la liste est vide.

3. Représentation des listes :

3.1. La représentation contiguë (Tableau):

! L’accès au Keme element est immédiate : T[K]

3.2. La représentation chainée (utilisation des pointeurs) :

Langage C Pascal (langage algorithmique)

struct element Type element = record

element* Suivant ; Suivant : ^element ;

element* e ; Var e : ^element ; Var e : ↑element ;

Le résultat d’exécution de ce bloc d’instructions est le suivant :

Champ1 ... ChampN Suivant

3.2.2. C’est quoi une liste exactement ? :

# T : un pointeur (adresse) de la première case.

4. Operations sur les listes chainées (langage C) :

4.1. Parcourir une liste :

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

#100 #50 #200

a) Analogie avec les tableaux :

Tableau Liste chainée

Etudiant T [N] ; Etudiant* liste ;

Création .... Voir la section ....

Int i ; Etudiant* position ;

i=0 ; Position = liste ;

While (i<N) While (position != NULL)

Printf ("%d", T[i].N) ; Printf ("%d", (*position).N) ;

i=i+1 ; Position = (*position).suivant ;

I=N Position= NULL

Etape1 : initialisation # position= Lise = #100;

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

Etape2 #la boucle while : 1ere incrémentation # position = (*position).suivant = #50;

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

Etape3 # la boucle while :2eme incrémentation # position = (*position).suivant = #200;

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

#100 #50 #200

Etape4 # la boucle while : 3eme incrémentation (dernière) # position = (*position).suivant = NULL;

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

#100 #50 #200

NB : A la fin de cette boucle le pointeur position = NULL.

4.2. Insérer un élément :

4.2.1. Insérer un élément à la fin de liste :

3 ‘’aa’’ #50 6 ‘’...’’ #200 2 ‘’...’’ NULL

#100 #50 #200

#100 #50 #200

Pour insérer un élément à la fin il faut suivre les étapes suivantes :

Etape1 : création dynamique d’un nouvel élément (utilisation des pointeurs)

Etape2 : initialisation de l’élément (lecture a partir d’un clavier) :

scanf ("%d", & (*e).N ) ;

Etape 4 : établir la liaison entre la liste et le nouvel élément

4.2.2. Insertion en tête de la liste

scanf ("%d", & (*e).N ) ;

Etape 2 : établir la 1ere liaison N1 dans le schéma.

Etape 3 : établir la 2eme liaison N2 dans le schéma.

4.2.3. Insertion au milieu :

Il existe plusieurs façons de savoir l’endroit d’insertion d’un élément :

Cas1 : insertion directe:

scanf ("%d", & (*e).N ) ;