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 1 place, en queue, au milieu)
ere

Supprimer un élément (le 1 élément, le dernier élément, un élément au milieu)

er

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).

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

M. bada 1
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

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 K element est immédiate : T[K]

eme

Ø 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 ;

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 :

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

(*e).champ1 (*e).suivant
e ou ou
e->champ1 e->suivant

#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.

Element* Liste ; Liste

Liste =NULL ; NULL

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

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

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

Etape1 : initialisation è position= Lise = #100;

Liste Position

#100 #100

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

*position
#50 #200

(*position).suivant

M. bada 4
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

Etape2 èla boucle while : 1 incrémentation

ere
è position = (*position).suivant = #50;

Liste Position

#100 #50

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

*position

#50 #200

(*position).suivant

Etape3 è la boucle while :2 incrémentation

eme
è position =
(*position).suivant = #200;

Position
Liste
#50
#100

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

#100 #50 #200

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

eme

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.

M. bada 5
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

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

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 ;

M. bada 6
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

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

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

Etudiant* e ;
e= (Etudiant*) = malloc (sizeof (Etudiant) ) ;

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

scanf ("%s", & (*e).Nom) ;

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

ere

(*e).suivant = liste ;

M. bada 7
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

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

eme

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 ;
e= (Etudiant*) = malloc (sizeof (Etudiant) ) ;

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 ;
}

Etape 3: établir la liaison N3 : entre le nouvel élément et la 2eme partie de la liste.

(*e).suivant = (*position).suivant ;

M. bada 8
Chapitre 3 : les listes Université de Batna 2 Algorithmique et structures de données

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

M. bada 9