Module: Algorithmique et

Structures de données
Niveau: 2P/3B Classe : 3 B 9
Date: 26-11-2019

1
 Objectifs Généraux du Module ASD
Objectif Général 1 : Donner à l’apprenant les capacités théoriques et pratiques lui
permettant de proposer Correctement une solution algorithmique relative à un
problème Structuré Simple.
Objectif Général 2 : Faire acquérir à l’apprenant les capacités théoriques et pratiques
lui permettant de proposer Correctement une solution algorithmique relative à un
problème Structuré et Complexe, en utilisant les concepts de la Programmation
Procédurale.
Objectif Général 3: Faire acquérir à l’apprenant les capacités théoriques et pratiques
lui permettant de proposer Correctement une solution algorithmique relative à un
problème Structuré et Complexe, en utilisant les Structures Dynamiques.
2
 Objectif Général 2
Objectif Général 3: Faire acquérir à l’apprenant les capacités théoriques et pratiques lui
permettant de proposer Correctement une solution algorithmique relative à un problème
Structuré et Complexe, en utilisant les Structures Dynamiques.
OBJECTIFS SPÉCIFIQUES

OS1 : COMPRENDRE LE CONCEPT POINTEUR.

OS2 : MAITRISER LES LISTES SIMPLEMENT CHAINÉES.
OS3: MAITRISER LES LISTES DOUBLEMENT CHAINÉES.
OS4 : MAITRISER LES PILES ET LES FILES.
OS5: COMPRENDRE LES ARBRES BINAIRES DE RECHERCHE.

3
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Éléments de Contenu
- Problématique.
- Définition d’une LSC.
- Principe d’une LSC.
- Historique des Listes.
- Représentation algorithmique et en C.
- Algorithme de Création d’une LSC.
- Algorithme de Parcours dans une LSC.
- Algorithmes d’Insertion d’une valeur dans une LSC.
- Algorithmes de Suppression dans une LSC.
Moyens Pédagogiques
- Exposé Informel
- Condensé du cours
- Évaluation formative : TD9 + Etude de Cas Pratique
4
 Objectif Spécifique 2: Maîtriser les Listes Simplement Chainées (LSC)
Problématique
- Nous avons implémenté un tableau de N entiers à l’aide de pointeurs sur enregistrement.
- En général, On ne peut pas savoir à l’avance le nombre d’éléments à créer lors de l’exécution.
- Exemple: On dispose d’un tableau de N étudiants, et on veut placer dans un autre tableau de taille
M, tous les étudiants dont la moyenne >=10.
Question 1 : Pensez-vous que le tableau des moyennes est la structure appropriée?
Réponse :NON
- Le nbre d’étudiants ayant la moyenne: Non connu l’avance Risque : Gaspillage ou Perte.
- Opter pour une SD dynamique capable de créer au fur et à mesure qu’on parcoure le tableau des
étudiants, des éléments reliés entre-eux et dont chacun contiendra seulement les enregistrements
dont la moyenne est >=10.
- Une Telle structure est appelée Liste Chainée.
- On distingue 3 Types de Listes : Listes Simplement Chainées (LSC), Listes Doublement Chainées
(LDC) et les Listes Circulaires (LC).

5
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Définition d’une LSC
Une Liste Simplement Chainée (LSC) est une structure de données permettant de représenter au
cours de l’exécution d’un programme des données de même type qui sont reliés entre eux par des
liens de chainage unidirectionnels (un seul sens).
Exemple :
Soit la liste L composée de trois éléments ayant respectivement les valeurs : 12, 99 et 37.
Schématiquement, elle est représentée de la manière suivante :
L
12   99   37  NIL

12 99 37 Cette représentation est-elle Correcte ?

6
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Caractéristiques d’une LSC
- Une Liste est constituée d’éléments appelés Cellules ou Nœuds ou encore Maillons.
- Une Cellule est structurée en deux parties : Une case comportant les Informations et une autre
case comportant l’adresse de la cellule suivante.
- Le premier élément de la liste est appelé Tête.
- Connaissant la Tête, on peut retrouver tous les autres éléments.
- La Tête doit être toujours sauvegardée.
- La dernière cellule de la liste doit toujours pointer sur NIL.

L : Tête de la Liste L
12   99   37  NIL

Informations Cellule @ Cellule Suivante

7
 Objectif Spécifique 2: Maîtriser les Listes Simplement Chainées (LSC)
Principe d’une LSC
- Le principe de la liste simplement chaînée est que chaque cellule possède, en plus des
informations, un pointeur vers la cellule qui lui est logiquement adjacente.
- De ce fait, l'usage d'une liste est préconisé pour des raisons de rapidité de traitement, lors des
insertions et suppressions.
- L’accès à une information de la liste est séquentiel.
- Le parcours dans une LSC est dans un seul sens.

L
12   99   37  NIL

8
 Objectif Spécifique 2: Maîtriser les Listes Simplement Chainées (LSC)
Bref Historique des Listes
- Allen Newell: Né le 19 mars 1927 à San Francisco, décédé le 19 juillet 1992 en
Pennsylvanie, il était un chercheur en informatique et psychologie cognitive à la
compagnie RAND Corporation et à l'école d'informatique de l'université Carnegie-Mellon.
- Herbert Simon: Né le 15 juillet 1916 à Wisconsin, décédé le 9 février 2001 en
Pennsylvanie, il était un économiste et sociologue américain ayant reçu le prix Nobel
d'économie en 1978. Il s'est d'abord intéressé à la psychologie cognitive à la
compagnie RAND Corporation et à la rationalité limitée qui constitue le cœur de sa pensée.
- Cliff Shaw: Né le 23 février 1922, décédé le 9 février 1991, il était un ingénieur
système (JOSS en 1960) à  RAND Corporation. Il est le coauteur du premier
programme en I.A.: Logic Theorist, et l'un des premiers développeurs de l‘Information
Processing Language (IPL), conçu en 1950. Il est l’inventeur du concept Liste Chainée.
En 1955-1956.
9
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Représentation Algorithmique d’une LSC
Il s’agit de déclarer la structure de données puis le pointeur vers le 1er élément.
Type
L
Liste = @Cellule
Cellule = Enregistrement Info Suiv
Info : Type_Info
Suiv : Liste
Fin Accès au champ Info : L@.Info
Variable Accès au champ Suiv: L@.Suiv
P, L : Liste
Remarque : L est un pointeur sur une la 1ère Cellule.

10
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Représentation en Langage C d’une LSC
struct <Nom_cellule>
{
// Déclaration des champs de données
// pointeur sur l’élément suivant L
};
Typedef struct<Nom_cellule>*pointeur_sur_premier_element; valeur suivant
Exemple : Déclarer une Liste d’Entiers
Accès au champ valeur: L->valeur
Struct Cellule Accès au champ suivant: L->suivant
{
int valeur ; // Déclaration des champs de la cellule
struct Cellule * suivant ; // pointeur sur l’élément suivant
};
Typedef struct Cellule * L; 
11
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme de Création d’une LSC

- Une LSC est constituée d'un ensemble de cellules chaînées entre elles.
- C'est l'adresse de la première cellule qui détermine la liste.
- Cette adresse est souvent appelée "Tête"  de la Liste.
- Cette adresse doit rester toujours à la disposition du programme (un traitement nécessite
généralement le placement en début de liste).
- Elle doit-être donc constamment Mémorisée.

12
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme de Création d’une LSC

Algorithme CreLsc
Type LSC=@Cellule
Tant que ((Rep=‘O’) ou (Rep=‘o’)) Faire
Cellule= Enregistrement
Allouer(p)
Valeur: Entier
Lire(p@.Valeur)
Suiv: LSC
p@.Suiv  NIL
Fin
q@.Suiv  p
Variable L,p,q: LSC
q  p //Pour ne pas écraser la dernière valeur de p//
Rep: Caractère
Fin Tant que
Début
Fin
//Création de la Tête de la liste//
Allouer(L)
Lire(L@.Valeur)
Question 1 : Tester cet algorithme pour créer la liste
L@.Suiv  NIL d’entiers : 6/-2/1/9/-1/4/0/5
q  L //Mémorisation de la tête qui est L// Question 2 : Quelle Amélioration peut-on faire à cet
Ecrire ("Voulez-vous Continuer la Saisie (O/N)? ") algorithme ?
Lire(Rep)
13
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Implémentation de l’Algorithme de Création d’une LSC

14
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme de Parcours d’une LSC

Exemple : Afficher les valeurs impaires contenues dans la liste L.
Algorithme ParcoursLsc
Remarque : Si on veut parcourir les adresse la condition
Type LSC=@Cellule
d’exécution deviendra (q@.Suiv<>NIL)
Cellule= Enregistrement
Valeur: Entier
Suiv: LSC Question : Tester cet algorithme sur la liste d’entiers:
Fin 6/-2/1/9/-1/4/0/5
Variable L,q: LSC
Début La Sortie devra être : 1, 9, -1, 5
q  L //Mémorisation de la tête qui est L//
Tant que (q<>NIL) Faire
Si (q@.ValeurMOD 2 <>0) Alors Ecrire(q@.Valeur) FinSi
q  q@.Suiv //Aller à la Cellule Suivante//
Fin Tant que
Fin
15
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Implémentation en C de l’Algorithme de Parcours d’une LSC

Exemple : Afficher les valeurs impaires contenues dans la liste L.
#include <stdio.h>
#include <stdlib.h>
#include <windows.h> while (q!=NULL)
struct cellule {
{ int valeur; if (q->valeur % 2 !=0) printf("%d, ",q-
struct cellule *suiv; >valeur);
}; q  q->Suiv;
struct cellule *L, *q; }
int main()
{ return 0;
system("CLS"); }
printf("\n ---- Creation d'une LSC ---\n");
q=L;

16
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes d’Insertion dans une LSC

On distingue 3 types d’insertion : Début, Milieu et en fin de liste
1er Cas : Insertion d’une valeur en Début de Liste
Etat Initial de la Liste
L

12   99   37  NIL

p
Créer une nouvelle Cellule p : Allouer(p); on placera par exemple la valeur 7.
7 NIL 

Rétablir le Chainage de la liste L

L, p L
12   99   37  NIL
7  

17
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme d’Insertion En début d’une LSC

Procédure InsDebLsc (DONRES L:LSC, DON x:Entier)
Variable p: LSC
Début
Allouer(p)
p@.Valeur  x
p@.Suiv  NIL
Si (L=NIL) Alors L  P
Sinon
L, p L
p@.Suiv  L
12   99   37  NIL
Lp 7  

FinSi
Fin
18
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Implémentation de l’Algorithme d’Insertion d’une valeur x en début d’une LSC

void InsDebLsc(struct cellule * L, int x)
{ struct cellule *p;
p = malloc(sizeof(struct cellule));
p->valeur  x
p->suiv  NULL
if (L== NULL) L= p;
else
{
L, p L
p->Suiv = L;
12   99   37  NIL
L = p; 7  

}
}
19
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes d’Insertion dans une LSC

2ème Cas : Insertion d’une valeur en Fin de Liste

Etat Initial de la Liste
L

12   99   37  NIL
p
Créer une nouvelle Cellule p : Allouer(p); on placera par exemple la valeur 7. 7 NIL 

q, L q
Parcourir la liste L jusqu’à la fin
12   99   37  NIL

Rétablir le Chaingage
p
L q
12   99   37 7 NIL 

20
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme d’Insertion d’une valeur x En Fin d’une LSC

Procédure InsFinLsc (DONRES L:LSC, DON x:Entier)
Variable p,q: LSC
Début
Allouer(p)
p@.Valeur  x
p@.Suiv  NIL
qL
Tant que (q@.Suiv <> NIL) Faire
q  q@.Suiv
p
Fin Tant que L q
q@.Suiv  p 12   99   37 7 NIL 

Fin
21
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Implémentation de l’Algorithme d’Insertion d’une valeur x En Fin d’une LSC

void InsFinLsc (struct cellule * L:LSC, int x)
{ struct cellule *p, *q;
p = malloc(sizeof(struct cellule));
p->Valeur = x;
p ->Suiv = NULL;
q = L;
while (q->Suiv != NULL) q = q->Suiv;
q->Suiv = p;
}
p
L q
12   99   37 7 NIL 

22
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes d’Insertion dans une LSC

3ème Cas : Insertion d’une valeur au Milieu de la Liste Après une Valeur V
Etat Initial de la Liste
L

12   99   37  NIL
p
Créer une nouvelle Cellule p : Allouer(p); on placera par exemple la valeur 7. 7 NIL 
Parcourir la liste jusqu’à atteindre la valeur V (V=99), puis insérer la valeur 7
q, L q
Rétablir le Chainage
12   99   37  NIL

 
p
L
12   99   7 37 NIL  7  

23
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme d’Insertion d’une valeur x Au Milieu d’une LSC après une valeur V
Procédure InsMilLsc (DONRES L:LSC, DON x:Entier, DON V:Entier)
Variable p, q: LSC
Début
Allouer(p)
p@.Valeur  x
p@.Suiv  NIL
qL
Tant que (q<> NIL) et (q@.Valeur<>V) Faire q  q@.Suiv Fin Tant que
Si (q@.valeur = V) Alors
p@.Suiv  q@.Suiv
q@.Suiv  p
Sinon Ecrire (V, ‘Inexistante dans la liste L‘)
Fin Si
Fin

24
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Implémentation de l’Algorithme d’Insertion Au milieu d’une LSC Après une valeur V

void InsMilLsc (struct cellule * L:LSC, int x, int V)
{ struct cellule *p, *q;
p = malloc(sizeof(struct cellule));
p->Valeur = x;
p ->Suiv = NULL;
q = L;
while (q->Suiv != NULL) && (q->valeur !=V) q = q->Suiv;
if (q->valeur ==V) {p->Suiv = q->Suiv; q->Suiv = p;}
else printf("%d est Inexistant dans la liste L",V);
}
L
7 37 NIL 
12   99  

25
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes de Suppression dans une LSC

On distingue 3 types de suppression : Début, Milieu et en fin de liste
1er Cas : Suppression d’une valeur en Début de Liste
Etat Initial de la Liste
L

12   99   37  NIL

L L
Rétablir le Chainage de la liste L 37  NIL
12   99  

26
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithme de Suppression En Début d’une LSC

Procédure SupDebLsc (DONRES L:LSC)
Variable q: LSC
Début
qL
L  L@.Suiv
Libérer(q)
Fin
Implémentation de l’Algorithme de Suppression En Début d’une LSC
void SupDebLsc (struct cellule *L)
{ struct cellule *q;
q = L;
L = L@.Suiv
free(q);
}
27
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes de Suppression dans une LSC

2ème Cas : Suppression d’une valeur en Fin de Liste

Etat Initial de la Liste
L

12   99   37  NIL

Rétablir le Chainage de la liste L

L

12   99 NIL  37  NIL

28
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Algorithme de Suppression En Fin d’une LSC
Procédure SupFinLsc (DONRES L:LSC)
Variable p,q: LSC
Début
qL
Tant que (q@.Suiv <> NIL) Faire pq q  q@.Suiv Fin Tant que
p@.Suiv  NIL
Libérer(q)
Fin
Implémentation de l’Algorithme de Suppression En Fin d’une LSC
void SupFinLsc (struct cellule *L)
{ struct cellule *q, *p;
q = L;
while (q->Suiv != NULL) { p=q; q = q->Suiv;}
p->Suiv = NULL;
free(q);
} 29
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)

Algorithmes de Suppression dans une LSC

2ème Cas : Suppression d’une valeur Au milieu de la Liste Après une valeur V
Etat Initial de la Liste
L

7 37 NIL 
12   99  

Rétablir le Chainage de la liste L après suppression de la valeur 7

7 37 NIL 
12   99  

30
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Algorithme de Au Milieu d’une LSC après une valeur V

Procédure SupMilLsc (DONRES L:LSC, DON V: Entier)

Variable p, q: LSC
Début
qL
Tant que (q<> NIL) et (q@.Valeur <> V) Faire q  q@.Suiv Fin Tant que
Si (q@.Valeur = V) Alors
pq@.Suiv
q@.Suiv  p@.Suiv
Libérer(p)
Sinon Ecrire (V, 'Inexistante dans la liste L')
FinSi
Fin

31
 Objectif Spécifique 2 : Maîtriser les Listes Simplement Chainées (LSC)
Implémentation de l’Algorithme de Suppression Au Milieu d’une LSC après une valeur V

void SupMilLsc (struct cellule *L, int V)

{ struct cellule *p, *q;
q = L;
while ((q!=NULL) && (q->Valeur != V) q =q->Suiv;
if (q->Valeur == V) {
p=q->Suiv
q->Suiv = p->Suiv
free(p)
else printf("%d est Inexistante dans la liste L", V);

32