Préface

Institut Supérieur Arts et Multimédia

Université de la Manouba

Algorithme et Structures de Données 2

Support de Cours

Mohamed Mohsen Gammoudi,

Professeur en informatique,
ISAMM, Université de la Manouba
gammoudimomo@gmail.com

Farah HARRATHI
Maître Assistant en Informatique
E-mail : harrathi.farah@gmail.com

Année universitaire 2015-2016

-i-
 Préface

Préface

Objectifs du cours :

Ce cours permettra aux étudiants de première année Licence fondamentale

informatique d’analyser un problème donné et de définir l’algorithme traduisant la
solution du problème d’une manière rigoureuse et optimisée et prête à être
traduite en utilisant un langage de programmation quelconque, comme ça était
demandé dans le programme du LMD.
De plus, l’étudiant sera capable de définir la structure de données adéquate au
problème à résoudre et par conséquent celle qui permettra d’optimiser
l’algorithme.
Nous attirons l’attention que ce support de cours est inspiré de plusieurs
références bibliographiques (livres et ressources disponibles sur le web).

Prérequis : Algorithme et structures de données 1

Volume horaire : 21h, TD : 42h
Bibliographie :
FABER. (2009). FABER F. INTRODUCTION A LA PROGRAMMATION EN ANSI-C,
http://www.ltam.lu/cours-c/, Date de consultation : 28 Juin 2009 .

HARDOUIN. (2009). HARDOUIN L. http://www.istia.univ-

angers.fr/~hardouin/cours_c.pdf, Date de constation : 19 Mai 2009 .

La Page de l'algorithmique. ( 2008). La Page de l'algorithmique.

http://algor.chez.com/index.html, .

LAPORTE. (2009). LAPORTE S.

http://btsig972.free.fr/cours/Algorithme/1e_annee/07.pdf, Date de
consultation : 09 Mai 2009 .

-ii-
 Préface

REBAINE. (1, 2009). REBAINE D.

http://wwwens.uqac.ca/~rebaine/8INF805/courslistespilesetfiles.pdf,
Date de consultation : 20 Mai 2009 .

REBAINE. (2,2009). REBAINE D.

http://wwwens.uqac.ca/~rebaine/8SIF109/Les%20arbres.pdf, Date de
consultation : 10 Septembre 2009 .

Shaffer. (2001). Shaffer C A. Practical Introduction to Data Structures and

Algorithm Analysis (C++ Edition) (2nd Edition) (chapitre2) .

TThomas et al. (2002). Thomas H. Cormen, Charles E. Leireson, Ronald L Rivest et

Clifford Stein, . «Introduction à l’algorithmique», cours et exercices 2ème
cycle Ecoles d’ingénieurs » , Edition Dunod, 2ème dition, Paris 2002.

-iii-
 Table des matières

Table des matières

1. Les listes chaînées ............................................................................................................. 8

1.1. Introduction ............................................................................................................................. 8
1.2. Notion de maillon ................................................................................................................... 8
1.3. Notion de liste chaînée ......................................................................................................... 8
1.4. Implémentation du type liste chaînée............................................................................ 9
1.4.1. Déclaration d’une variable de type liste ........................................................................... 9
1.4.2. Accès aux champs d’un maillon d’une liste ..................................................................... 9
1.4.3. Initialisation d’une liste à Nil ............................................................................................. 10
1.5. Insertion d’une valeur en tête d’une liste .................................................................. 10
1.6. Récupérer l’adresse du dernier élément d’une liste .............................................. 11
1.7. Insertion d’une valeur en queue d’une liste ............................................................. 12
1.8. Longueur d’une liste .......................................................................................................... 13
1.9. Insertion d’une valeur à une position k dan une liste ........................................... 14
1.10. Suppression du premier maillon d’une liste ................................................. 15
1.11. Suppression du dernier maillon d’une liste ................................................... 17
1.12. Suppression de tous les maillons d’une liste................................................ 18
1.13. Les listes circulaires ................................................................................................ 18
1.14. Les listes doublement chaînée ............................................................................ 19
1.14.1. Le type liste doublement chaînée ..................................................................... 19
1.14.2. Insertion d’une valeur au en tête d’une liste doublement chainée. ... 20
1.15. Suppression du premier maillon d’une liste doublement chaînée ....... 21
2. Les piles ............................................................................................................................. 23
2.1. Définition et exemple......................................................................................................... 23
2.2. Opérations sur les piles .................................................................................................... 23
2.3. Implantation d’une pile par liste chaînée .................................................................. 23
2.4. Les opérations sur une pile ............................................................................................. 24
2.5. Une application des piles : le calcul arithmétique ................................................. 25
3. Les files .............................................................................................................................. 27
3.1. Définition ................................................................................................................................ 27
3.2. Les opérations sur une file .............................................................................................. 27
3.3. Implantation d’une file par liste chaînée ................................................................... 28

-iv-
 Table des matières

3.4. Les opérations sur une file .............................................................................................. 28

4. Les arbres.......................................................................................................................... 30
4.1. Introduction .......................................................................................................................... 30
4.2. Terminologie de base et définitions ............................................................................ 31
4.3. Parcours d’arbres ................................................................................................................ 32
5. Les arbres binaires ........................................................................................................ 34
5.1. Définition ................................................................................................................................ 34
5.2. Implémentation du type arbre binaire ....................................................................... 34
5.2.1. Déclaration d’une variable de type arbre ..................................................................... 34
5.2.2. Accès aux champs d’un nœud d’un arbre binaire ..................................................... 35
5.3. Insertion d’un nœud d’une valeur v dans un arbre binaire ................................ 35
5.4. Parcours d’un arbre binaire ............................................................................................ 35
5.4.1. Parcours Prefixe ...................................................................................................................... 35
5.4.2. Parcours Infixe......................................................................................................................... 35
5.4.3. Parcours Postfixé .................................................................................................................... 36
5.5. Tester si un Nœud est une feuille ................................................................................. 36
5.6. Nombre de feuilles dans un arbre binaire ................................................................. 36
6. Les arbres binaires de recherche ............................................................................. 37
6.1. Définition ................................................................................................................................ 37
6.2. Ajout d’une valeur dans un ABR .................................................................................... 37
6.3. Recherche d’une valeur dans un ABR ......................................................................... 39
6.4. Recherche du nœud père d’une valeur dans un ABR ............................................ 40
6.5. Recherche du max d’un ABR ........................................................................................... 41
6.6. Suppression d’une valeur dans un ABR ...................................................................... 41
7. Introduction à la complexité ...................................................................................... 46
7.1. Introduction .......................................................................................................................... 46
7.2. Les opérations élémentaires et notion d’instance.................................................. 46
7.3. Définition ................................................................................................................................ 47
7.4. Calculs élémentaires de complexité ............................................................................. 47
7.4.1. Si...Sinon...................................................................................................................................... 47
7.4.2. La boucle pour ......................................................................................................................... 48
7.4.3. La boucle tantque ................................................................................................................... 48
7.5. Exemple : le tri par insertion .......................................................................................... 48
8. Série 1 : Enoncé ............................................................................................................... 50

-v-
 Table des matières

Série 1 : correction .............................................................................................................. 51

Série 2: Enoncé ..................................................................................................................... 53
Série 2: correction ............................................................................................................... 55
Série 3 : Enoncé .................................................................................................................... 57
Série 3: correction ............................................................................................................... 58
Série 4 : Enoncé .................................................................................................................... 61
Série 4: correction ............................................................................................................... 62
Série 5 : Enoncé .................................................................................................................... 64
Série 5: correction ............................................................................................................... 66

-vi-
 Table des figures

Table des figures

Figure ‎1.1-Structure d’un maillon dans une liste chaînée ................................................ 8

Figure ‎1.2-une liste chaînée .............................................................................................. 9
Figure ‎1.3-la liste avant l’insertion de la valeur val en tête ........................................... 10
Figure ‎1.4-la liste aprés l’insertion de la valeur val en tête ........................................... 10
Figure ‎1.5-la liste avant l’insertion ................................................................................ 11
Figure ‎1.6-la liste avant l’insertion de la valeur val en queue ....................................... 12
Figure ‎1.7-la liste aprés l’insertion de la valeur val en queue ....................................... 12
Figure ‎1.8-la liste avant l’insertion de la valeur val à la position k=2 ............................ 14
Figure ‎14.9-la liste aprés l’insertion de la valeur val à la position k=2 .......................... 14
Figure ‎1.10-la liste avant la suppression du premier élément ...................................... 16
Figure ‎1.11-la liste aprés la suppression du premier élément ...................................... 16
Figure ‎1.12-la liste avant la suppresion du dernier maillon .......................................... 17
Figure ‎1.13-la liste aprés la suppresion du dernier maillon .......................................... 17
Figure ‎1.14-Une liste circulaire ....................................................................................... 19
Figure ‎1.15-Structure d’un maillon dans une liste doublement chaînée ....................... 19
Figure ‎1.16-Une liste doublement chaînée .................................................................... 20
Figure ‎3.1-La file résultat ................................................................................................ 27
Figure ‎3.2-La file résultat àprés l’appel de Defiler (f) ..................................................... 28
Figure ‎3.3-La file résultat àprés l’appel de Enfiler (f, D) er Enfiler(f,E) ........................... 28
Figure ‎4.1-L’arbre de l’expression .................................................................................. 31
Figure ‎4.2-L’arbre représentant un livre ........................................................................ 31
Figure ‎4.3-Parcours d’un arbre ....................................................................................... 33
Figure ‎5.1-Exemple d’ arbre binaire ............................................................................... 34
Figure ‎6.1-un arbre binaire de recherche ....................................................................... 37
Figure ‎6.2-L’ ABR avant l’ajout de la valeur 6 ................................................................. 38
Figure ‎6.3-L’ ABR aprés l’ajout de la valeur 6 ................................................................. 38

-vii-
 ‎1.1. Introduction

Chapitre 1

Les listes chaînées

1.1. Introduction

Une liste chaînée permet de stocker un ensemble de valeur du même type,

comme un tableau. Contrairement au tableau, la taille de la liste chaînée peut
varier au cours du temps. En effet, contrairement au tableau, la liste n'est pas
allouée en une seule fois, mais chaque élément est alloué indépendamment, sous la
forme d'un maillon.

1.2. Notion de maillon

L'élément de base d'une liste chaînée s'appelle le maillon. Il est constitué : d’un
champ de données et d'un pointeur vers un maillon.

Données
pointeur

Figure ‎1.1-Structure d’un maillon dans une liste chaînée

Le champ pointeur vers un maillon pointe vers le maillon suivant de la liste. S'il
n'y a pas de maillon suivant, le pointeur vaut NIL.

1.3. Notion de liste chaînée

Dans une liste chaînée, chaque élément pointe, à l'aide d’un pointeur (suivant)
vers l'élément suivant dans la liste ; le dernier élément, par définition, n'a pas de
suivant, donc son pointeur suivant vaut nil.

-8-
 ‎1.4. Implémentation du type liste chaînée

premier

Figure ‎1.2-une liste chaînée

Pour manipuler une liste chaînée, nous manipulons un pointeur sur le premier
élément; comme chaque élément « connaît » l'élément suivant, on peut ainsi
accéder à tous les éléments de la liste. Notons enfin que si le pointeur premier vaut
nil, on considérera naturellement que la liste est vide (elle ne contient aucun
élément).
Le premier maillon de la liste est appelé tête, le dernier maillon de la liste est
appelé queue.

1.4. Implémentation du type liste chaînée

Un maillon est composé de deux champs de types hétérogènes, il est

implémenté donc en utilisant les enregistrements de la manière suivante :
Type maillon = Enregistrement
Valeur : entier
Suivant : ^maillon
FinEnregistrement

Par la suite nous définissons le type liste comme étant un maillon.

Type liste =maillon

1.4.1. Déclaration d’une variable de type liste

Une fois le type liste est défini on peut déclarer une variable de type pointeur
sur liste de la manière suivante :
p : ^liste

1.4.2. Accès aux champs d’un maillon d’une liste

Si p est un pointeur sur une variable de type liste, p^ est la variable pointée par
p. Cette variable est un enregistrement, pour accéder à ses champs on utilise
l’opérateur "." .
p^. valeur

-9-
 ‎1.5. Insertion d’une valeur en tête d’une liste

p^. suivant

1.4.3. Initialisation d’une liste à Nil

Une liste est vide si le pointeur du premier maillon est vaut nil.
pNil

1.5. Insertion d’une valeur en tête d’une liste

Ecrire la procédure InserTete qui permet d’insérer une valeur val en tête d’une
liste chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après l’insertion la valeur du premier sera changée, donc le passage
doit se faire par adresse.

premier

Figure ‎1.3-la liste avant l’insertion de la valeur val en tête

premier
val

Figure ‎1.4-la liste aprés l’insertion de la valeur val en tête

Principe

1. Créer un maillon d’adresse p1 contenant la valeur v

 p1nouveau(^liste)
 p1^.valeurval
2. Créer un lien entre le nouveau maillon et la tête de la liste de telle sorte que
p soit le suivant de p1
 p1^.suivant premier
3. Le maillon p1 devient le premier maillon de liste p
 premier p1

-10-
 ‎1.6. Récupérer l’adresse du dernier élément d’une liste

Algorithme

PROCEDURE InsertTete(var p : ^liste, val : entier)

Variable
p1: ^liste
Debut
p1nouveau(^liste)
p1^.valeurval
p1^.suivant premier
premier p1
Fin

1.6. Récupérer l’adresse du dernier élément d’une liste

Ecrire la procédure Dernier qui renvoie l’adresse du dernier élément d’une liste
donnée par l’adresse de son premier élément (premier).

premier

Dernier

Figure ‎1.5-la liste avant l’insertion

Principe

Le dernier élément de la liste s’il existe est un maillon qui ne possède pas de
suivant. On fait le parcours de liste du premier élément jusqu’à trouver un maillon
dont le suivant vaut nil. L’adresse de ce maillon est renvoyée par la fonction.

Algorithme

Fonction Dernier(premier : ^liste) : ^liste

Debut
tantque(premier <>Nil et premier ^.suivant<>Nil) faire
premier  premier ^.suivant
Fintantque
Dernier premier
Fin

-11-
 ‎1.7. Insertion d’une valeur en queue d’une liste

1.7. Insertion d’une valeur en queue d’une liste

Ecrire la procédure InsertQueue qui permet d’insérer une valeur val dans une
liste chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après l’insertion la valeur du premier peut changer (dans le cas où la
liste est vide) donc le passage doit se faire par adresse.

premier

Figure ‎1.6-la liste avant l’insertion de la valeur val en queue

premier
val

Figure ‎1.7-la liste aprés l’insertion de la valeur val en queue

Principe

Deux cas:
1. Si la liste est vide l’insertion en queue est une insertion en tête.
si(premier =Nil) alors
InsertTete(p,val)
2. Sinon
 créer un maillon d’adresse p1 contenant la valeur v et dont l’élément
suivant est Nil
sinon
p1nouveau(^liste)
p1^.valeurval
p1^.suivantNil
 Récupérer l’adresse du dernier maillon (Der) et p1 devient le suivant de
Der
Der  dernier(premier)
-12-
 ‎1.8. Longueur d’une liste

Der^.suivantp1
Finsi

Algorithme

PROCEDURE InsertQueue(var premier : ^Liste, val : entier)

Variable
p1,Der: ^liste
Debut
si(p=Nil) alors
InsertTete(premier,val)
Sinon
p1nouveau(^liste)
p1^.valeurval
p1^.suivantNil// il sera le dernier
Der  dernier(premier)
Der^.suivantp1
Finsi
Fin

1.8. Longueur d’une liste

Ecrire la fonction LongListe qui permet de renvoyer le nombre d’élément d’une

liste chaînée donnée par l’adresse de son premier élément (premier). La fonction
renvoie 0 si la liste est vide.

Principe

On fait le parcours de liste du premier élément jusqu’au dernier en

incrémentant un compteur de 1 à chaque passage d’un maillon a son suivant. La
valeur de ce compteur au départ vaut 0
FONCTION LongListe(premier : ^liste) : entier
Variable
l : entier
Debut
l0
Tantque(premier <>Nil) faire
ll+1
premier  premier ^.suivant
fintantque
LongListel
Fin

-13-
 ‎1.9. Insertion d’une valeur à une position k dans une liste

1.9. Insertion d’une valeur à une position k dans une liste

Ecrire la procédure Insertk qui permet d’insérer une valeur val à une position k
dans une liste chaînée donnée par l’adresse de son premier élément (premier). La
valeur val aura le rang k+1 dans la liste après l’insertion.
Notons qu’après l’insertion la valeur du premier peut changer (dans le cas où
k=0) donc le passage doit se faire par adresse.

premier

Figure ‎1.8-la liste avant l’insertion de la valeur val à la position k=2

premier
val

pk

Figure ‎1.9-la liste aprés l’insertion de la valeur val à la position k=2

Principe

1. Si k=0 l’insertion se fait en tête de la liste.

si(k =0) alors
InsertTete(p,val)
2. Sinon
 si k > long(premier), l’insertion est impossible.
sinon
si(k>LongListe(premier)) alors
ecrire("la position k=" ,k, " n'existe pas car la liste est de
taille",LongListe(premier))

 Sinon
- Récupérer l’adresse du maillon qui se trouve à la position k (pk).
sinon
pour i de 1 a k faire
pkpk^.suivant;
-14-
 ‎1.10. Suppression du premier maillon d’une liste

finpour

- créer un maillon d’adresse p1 contenant la valeur val et dont

l’élément suivant est Nil
p1nouveau(^liste)
p1^.valeurval
- Le suivant de p1 est le suivant de pk.
P1^.suivant pk^.suivant
- Le suivant de pk est p1.
pk^.suivant p1
Finsi
Finsi

Algorithme

PROCEDURE Insertk(p ^liste , k: entier,val: entier)

Variable
p1,pk : ^liste
i: entier
debut
si(k =0) alors
InsertTete(premier,val)
sinon
si(k>LongListe(premier)) alors
ecrire("la position k=" ,k, " n'existe pas car la liste est de
taille",LongListe(premier))
sinon
pkpremier
pour i de 1 a k faire
pkpk^.suivant;
finpour
p1nouveau(^liste)
p1^.valeurval
p1^.suivantpk^.suivant
pk^.suivantp1
Finsi
Finsi
Fin

1.10. Suppression du premier maillon d’une liste

Ecrire la procédure SuppTete qui permet de supprimer le premier maillon d’une

liste chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après la suppression la valeur du premier doit changer, donc le
passage doit se faire par adresse.

-15-
 ‎1.10. Suppression du premier maillon d’une liste

premier

Figure ‎1.10-la liste avant la suppression du premier élément

premier

Figure ‎1.11-la liste aprés la suppression du premier élément

Principe

1. si la liste est non vide

 on sauvegarde premier dans une variable p.
si(premier ≠ Nil) alors
ppremier
 la valeur de premier prend la valeur de son suivant.
premierpremier^.suivant
 on libère la zone mémoire d’adresse p.
liberer(p)
finsi

Algorithme

PROCEDURE SuppTete(var premier : ^Liste)

Variable
p : ^Liste
Debut
si(premier ≠ Nil) alors
p premier
premier  premier ^.suivant
liberer(p)
finsi
Fin

-16-
 ‎1.11. Suppression du dernier maillon d’une liste

1.11. Suppression du dernier maillon d’une liste

Ecrire la procédure SuppQueue qui permet de supprimer le dernier maillon

d’une liste chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après la suppression la valeur du premier peut changer (dans le cas
où la liste contient un seul élément, LongListe(premier)=1), donc le passage doit se
faire par adresse.

premier

AvDer

Figure ‎1.12-la liste avant la suppresion du dernier maillon

premier

Figure ‎1.13-la liste aprés la suppresion du dernier maillon

Principe

1. si la liste est vide ou la liste contient un seul élément, la suppression se fait

en tête de la liste
si(premier = Nil ou LongListe(premier)=1) alors
SuppTete(premier)
2. Sinon,
 On récupère l’adresse de l’avant dernier élément (AvDer)
Sinon
AvDer  premier
tantque(AvDer ^.suivant^.suivant) faire
AvDer  AvDer ^.suivant
fintantque
 on sauvegarde l’adresse du dernier élément dans une variable p.
p  AvDer ^.suivant
 l’élément d’adresse AvDer devient le dernier élément.

-17-
 ‎1.12. Suppression de tous les maillons d’une liste

AvDer ^.suivantNil
 on libère la zone mémoire d’adresse p.
liberer(p)
finsi

Algorithme

PROCEDURE SuppFin(var premier: ^liste)

Vaiable
AvDer,p : ^liste
Debut
si((p=Nil) ou LongListe(premier)=1)
SuppTete(p)
sinon
AvDer premier
Tantque(AvDer ^.suivant^.suivant)faire
AvDer  AvDer ^.suivant
fintantque
p AvDer ^.suivant
AvDer ^.suivantNil
liberer(p)
finsi
fin

1.12. Suppression de tous les maillons d’une liste

Ecrire la procédure SuppListe qui permet de supprimer tous les éléments d’une
liste chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après la suppression la valeur du premier vaut nil, donc le passage
doit se faire par adresse.

Algorithme

PROCEDURE SuppFin(var premier: ^liste)

Debut
Tantque(premier≠Nil)faire
SuppTete(premier)
fintantque
fin

1.13. Les listes circulaires

Une liste où le pointeur nil du dernier élément est remplacé par l’adresse du
premier élément est appelée liste circulaire.
Dans une liste circulaire tous les maillons sont accessibles à partir de n’importe
quel autre maillon. Une liste circulaire n’a pas de premier et de dernier maillon.
-18-
 ‎1.14. Les listes doublement chaînée

Par convention, on peut prendre le pointeur externe de la liste vers le dernier

élément et le suivant serait le premier élément de la liste.

liste

Figure ‎1.14-Une liste circulaire

1.14. Les listes doublement chaînée

Dans une liste doublement chaînée un maillon est composé de trois champs :
 un champ de données ;
 un pointeur vers un le maillon suivant.
 un pointeur vers un le maillon précédent.

Données
Précédent suivant

Figure ‎1.15-Structure d’un maillon dans une liste doublement chaînée

suivant : Le champ pointeur vers un maillon pointe vers le maillon suivant de la

liste. S'il n'y a pas de maillon suivant, le pointeur vaut NIL.
Précédent : Le champ pointeur vers un maillon pointe vers le maillon
précédent de la liste. S'il n'y a pas de maillon précédent, le pointeur vaut NIL.

1.14.1. Le type liste doublement chaînée

Type maillon = Enregistrement

Valeur : entier
Suivant : ^maillon
precedent: ^maillon
FinEnregistrement
//Défintion du type listedc
type listedc =maillon

-19-
 ‎1.14. Les listes doublement chaînée

premier

Figure ‎1.16-Une liste doublement chaînée

1.14.2. Insertion d’une valeur au en tête d’une liste doublement

chainée.

Ecrire la procédure InserTete qui permet d’insérer une valeur v en tête d’une
liste doublement chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après l’insertion la valeur du premier sera changée donc le passage
doit se faire par adresse.

Principe

1) Créer un maillon d’adresse p1 contenant la valeur v et dont le pointeur

précédent est nil (il sera le premier).
p1nouveau(^listedc)
p1^.valeurv
p1^.precedentNil
2) Créer un lien entre le nouveau maillon et la tête de la liste de telle sorte que
p soit le suivant de p1
p1^.suivantp
3) Créer un lien entre la tête de la liste (si elle existe) et le nouveau maillon de
telle sorte que p1 soit le précédent de p.
Si (p<>nil) alors
p^.precedentp1
Finsi
4)Le maillon p1 devient le premier maillon de liste p
pp1

Algorithme

PROCEDURE InsertTete(var p : ^listedc, v : entier

Variable
p1: ^listedc
Debut

-20-
 ‎1.15. Suppression du premier maillon d’une liste doublement chaînée

p1nouveau(^liste)
p1^.valeurv
p1^.precedentNil
p1^.suivantp
si(p<>nil) alors
p^.precedenttp1
Finsi
pp1
Fin

1.15. Suppression du premier maillon d’une liste doublement

chaînée

Ecrire la procédure SuppTete qui permet de supprimer le premier maillon d’une

liste doublement chaînée donnée par l’adresse de son premier élément (premier).
Notons qu’après la suppression la valeur du premier maillon doit changer, donc
le passage doit se faire par adresse.

Principe

Deux cas:
1) Si la liste est vide l’insertion en queue est une insertion en tête.
si(p=Nil) alors
InsertTete(p,v)
2) Sinon
 créer un maillon d’adresse p1 contenant la valeur v et dont l’élément
suivant est Nil
p1nouveau(^liste)
p1^.valeurv
p1^.suivantNil
 Récupérer l’adresse du dernier maillon Der, p1 devient le suivant de
Der et Der devient le précédent de p1
Der  dernier(p)
Der^.suivantp1
p1^.precedentDer
Finsi

Algorithme

PROCEDURE InsertQueue(var p : ^listedc)

-21-
 ‎1.15. Suppression du premier maillon d’une liste doublement chaînée

variable
p1,Der : ^listedc
Debut
si(p=Nil) alors
InsertTete(p,v)
Sinon
P1nouveau(^listedc)
P1^.valeurv
p1^.suivantNil// il sera le dernier
Der  dernier(p)
Der^.suivantp1
p1^.precedentDer
Finsi
Fin

-22-
 ‎2.1. Définition et exemple

Chapitre 2

Les piles

2.1. Définition et exemple

Une pile est une liste ordonnée sans fin d’éléments dans laquelle on ne peut
introduire ou enlever un élément qu'à une extrémité appelée tête de pile ou
sommet de pile.

Exemple

 une pile de livres, une pile d’assiettes,

 une pile à un jeu de cartes
Dans une pile, le dernier élément inséré sera le premier à être supprimé,
(retiré) : on parle de liste LIFO (Last In First Out).

2.2. Opérations sur les piles

Les opérations de base sur les piles sont :

 Empiler (p, e) (en anglais push) : empile l’élément e dans la pile p
 Dépiler (p) (en anglais pop): dépile un élément de la pile et retourne la
valeur de cet élément (e  Depiler (p))
Toutes les opérations sont effectuées sur la même extrémité; on parle de
structure en FIFO.
Il n’y a aucune limite au nombre d’éléments qu’on peut empiler. Par contre, on
ne peut dépiler d’une pile vide. A cet effet, on a une fonction PileVide(p) qui
retourne Vrai si la pile est vide sinon Faux.
InitialiserPile(p) ou ViderPile(p) : vide la pile p
On peut vouloir aussi connaître le sommet de pile sans le supprimer (dépiler).
e  SommetDePile(p)

2.3. Implantation d’une pile par liste chaînée

L’implantation d’une pile par une liste (simplement) chaînée est une version
simplifiée de celle d’une liste par liste chaînée.

-23-
 ‎2.4. Les opérations sur une pile

Type Pile=enregistrement
ListeElem : ^liste
finenregistrement

2.4. Les opérations sur une pile

PROCEDURE InitialiserPile(p : Pile)

Debut
p. ListeElem Nil
fin

FONCTION PileVide(p : Pile) : booléen

Debut
PileVide( p. ListeElem =Nil)
Fin

PROCEDURE Empiler (p : Pile, e : entier)

Debut
InsertTete(p. ListeElem, e)
Fin

FONCTION Dépiler (p : Pile) : entier

Variable
e : entier
Debut
si (PileVide(p)) alors
ecrire ("la pile est vide")
sortir
sinon
e p. ListeElem^.valeur
SuppTete(p. ListeElem)
Dépilere
finsi
Fin

FONCTION SommetDePile (p : Pile) : entier

Debut
si (PileVide(p)) alors
ecrire ("la pile est vide")
sinon
SommetDePile  p. ListeElem^.valeur
finsi
Fin

-24-
 ‎2.5. Une application des piles : le calcul arithmétique

2.5. Une application des piles : le calcul arithmétique

Appliquons les piles pour l’évaluation d’une expression arithmétique afin

d’éviter l’usage des parenthèses.
La notation postfixée consiste à placer les opérandes devant l'opérateur.

Exemple

(3 + 5) * 2 s'écrira en notation postfixée : 3 5 + 2 *, alors que 3 + (5 * 2) s'écrira: 3 5

2*+
Notation infixe: A * B/C. En notation postfixe est: AB * C/.
On voit que la multiplication vient immédiatement après ses deux opérandes A
et B.
Imaginons maintenant que A * B est calculé et stocké dans T. Alors la division /
vient juste après les deux arguments T et C.
On suppose que l’expression à évaluer soit en forme postfixe et elle est stockée
dans un tableau de caractère t. Chaque case de t contient un entier ou un
opérateur. La fonction EvalPostfixe est la suivante :
FONCTION EvalPostfixe (t : tableau[1..200] de caractère, n entier) : entier
Variable
p :pile
g,d,i,e : entier
debut
i1
tantque(i<=n) faire
si(estopératuer(t[i]) alors
gdepiler(p)
ddepiler(p)
eeval(g,e[i],d)
empiler(p,e)
sinon
empiler(val(t[i]))
finsi
ii+1
fintantque
e depiler(p)
si(PileVide(p)) alors
EvalPostfixee
Sinon
ecrire("erreur ?")
sortir
finsi
fin

-25-
 ‎2.5. Une application des piles : le calcul arithmétique

FONCTION val (c : caractère) : entier

Debut
valORD(c)-ORD(‘0’)
fin
FONCTION eval (g : caractère, op : caractère, d : caractère) : entier
Debut
selon (op)
‘+’ : evalval(g)+val(d)
‘-‘ : evalval(g)+val(d)
‘*’ : evalval(g)+val(d)
‘/’ : si(val(d)=0) alors
ecrire("erreur ?")
sortir
sinon
evalval(g)/val(d)
finsi
autre : ecrire("erreur ?")
sortir
finselon
fin

-26-
 ‎3.1. Définition

Chapitre 3

Les files

3.1. Définition

Une file est une structure de données dynamique dans laquelle on insère des
nouveaux éléments à la fin (queue) et on enlève des éléments au début (tête de
file) (REBAINE, 1, 2009).

Exemple

 clients devant un guichet,

 les travaux en attente d’exécution dans un système de traitement par lots
 les messages en attente dans un commutateur de réseau téléphonique.
Dans une file, le premier élément inséré est aussi le premier retiré. On parle de
mode d’accès FIFO (Fisrt In Fist Out). Contrairement à la pile, la file est modifiée à
ses deux bouts.

3.2. Les opérations sur une file

Les opérations primitives sur une file sont :

Defiler pour le retrait d’un élément
Enfiler pour l’ajout d’un élément. L’opération Enfiler (f, e) ajoute l’élément e à la
fin de la file f.
Ainsi, la suite des opérations Enfiler (f, A), Enfiler (f, B) et Enfiler (f, C) donnent
la file suivante :

A B C

Tete Fin

Figure ‎3.1-La file résultat

Noter qu’en principe, il n’y aucune limite aux nombres d’éléments que l’on peut
ajouter dans une file.
L’opération e  Defiler (f), retire (supprime) un élément de la fin de la file et
renvoie sa valeur dans e.
Ainsi l’opération e  Defiler (f) provoque un changement d’état de la et met
l’élément A dans e.

-27-
 ‎3.3. Implantation d’une file par liste chaînée

B C

Tete Fin

Figure ‎3.2-La file résultat àprés l’appel de Defiler (f)

L'opération Defiler ne peut s’effectuer sur une file vide. Il faudra donc utiliser
une opération FileVide qui permet de tester si une file est vide ou pas.
Le résultat des opérations Enfiler (f, D) et Enfiler (f, E) est donné par la figure
précédente.

B C D E

Tete Fin

Figure ‎3.3-La file résultat àprés l’appel de Enfiler (f, D) er Enfiler(f,E)

3.3. Implantation d’une file par liste chaînée

L’implantation d’une pile par une liste (simplement) chaînée est une version
simplifiée de celle d’une liste par liste chaînée.
Type File=enregistrement
ListeElem : ^liste
finenregistrement

3.4. Les opérations sur une file

PROCEDURE InitialiserFile(p : File)

Debut
p. ListeElem nil
fin

FONCTION FileVide(p : File) : booléen

Debut
PileVide( p. ListeElem =nil)
Fin

PROCEDURE Enfiler (p : File, e : entier)

Debut
InsertQueue(p. ListeElem,e)
Fin

-28-
 ‎3.4. Les opérations sur une file

FONCTION Defiler (p : Pile) : entier

Variable
e : entier
Debut
si (FileVide(p)) alors
ecrire ("la File est vide")
sortir
sinon
e p. ListeElem^.valeur
SuppTete(p. ListeElem)
Dépilere
finsi
Fin

-29-
 ‎4.1. Introduction

Chapitre 4

Les arbres

4.1. Introduction

Un arbre est par définition a une structure hiérarchique. La structure d’arbre

très utilisée dans tous les domaines, parce que bien adaptée à la représentation
naturelle d’informations homogènes organisées, et d’une grande commodité et
rapidité de manipulation (REBAINE, 2,2009).

Exemples :

 découpage d’un livre en parties, chapitres, sections, paragraphes . . .,

 hiérarchies de fichiers,
 expressions arithmétiques,
 compression de données (code Huffman),
 décomposition syntaxique,
 tri,
 etc.
L’expression A - (B + C * (D - E)) * F se représente facilement par un arbre où
apparaît clairement la priorité des opérations:

-30-
 ‎4.2. Terminologie de base et définitions

Figure ‎4.1-L’arbre de l’expression

4.2. Terminologie de base et définitions

Un arbre est constitué de nœuds et de liens hiérarchiques entre ces nœuds. Un

nœud.

Figure ‎4.2-L’arbre représentant un livre

Chaque élément de l’arbre (nœud) possède un prédécesseur et peut avoir plus

d’un successeur. Dans la figure précédente, C1, C2 et C3 qui constituent les
chapitres du livre sont tous successeurs du nœud livre.
Une feuille est un nœud qui n’a pas de successeur (C3).
La racine est un nœud qui n’a pas de prédécesseur (Livre).
Tout autre nœud a un et un seul prédécesseur. Un nœud qui n’est ni une feuille
ni la racine est appelé nœud intérieur.

-31-
 ‎4.3. Parcours d’arbres

Chemin : Si n1, n2, .., nk, sont des nœuds d’un arbre et que ni est le parent de
ni+1 pour 1 ≤ i ≤ k, cette suite est appelée chemin entre le nœud nk et le nœud nk . La
longueur d’un chemin est le nombre de nœuds qu’il contient -1 (c’est en fait le
nombre de segments ou arcs).
La profondeur d’un sommet v est la longueur du chemin qui va de la racine à ce
sommet, on écrit prof(v)
Le niveau p est formé des sommets de profondeur p.
La hauteur d’un arbre est un de plus que la longueur du plus long chemin de la
racine à une feuille. Un arbre vide est de hauteur 0.

4.3. Parcours d’arbres

Le parcours d’un arbre s’effectue dans un certain ordre pour visiter tous ses
nœuds. Les parcours les plus classiques sont les parcours infixé, préfixé et postfixé.
Ces parcours sont définis récursivement de la manière suivante :
1- Infixe (symétrique) : on parcourt d’abord le premier sous-arbre en infixé,
puis la racine, puis
Chacun des autres sous-arbres, en infixe.
2- Préfixe : on parcourt d’abord la racine, puis chacun des sous-arbres en
préfixe.
3- Postfixe : on parcourt d’abord tous les sous-arbres en postfixe, puis on
parcourt la racine.

-32-
 ‎4.3. Parcours d’arbres

Figure ‎4.3-Parcours d’un arbre

1- infixe : L J E B F A C G D H K I
2- préfixe : A B E J L F C D G H I K
3- postfixe : L J E F B C G H K I D A

-33-
 ‎5.1. Définition

Chapitre 5

Les arbres binaires

5.1. Définition

Les arbres binaires sont un cas particulier d’arbres. Ce sont des arbres où
chaque nœud possède au plus un fils gauche et au plus un fils droit. Si un nœud
possède un seul fils, il est soit un fils gauche ou un fils droit.

Exemple

Figure ‎5.1-Exemple d’ arbre binaire

5.2. Implémentation du type arbre binaire

Dans un arbre binaire, Un nœud est composé de trois champs de types

hétérogènes, il est implémenté donc en utilisant les enregistrements de la manière
suivante :
Type nœud = Enregistrement
valeur : entier
filsg : ^ nœud
filsd : ^ nœud
FinEnregistrement

Par la suite on définit le type liste comme étant un maillon.

Type arbre = nœud

5.2.1. Déclaration d’une variable de type arbre

Une fois le type arbre est défini on peut déclarer une variable de type pointeur
sur arbre de la manière suivante :

-34-
 ‎5.3. Insertion d’un nœud d’une valeur v dans un arbre binaire

p : ^arbre

5.2.2. Accès aux champs d’un nœud d’un arbre binaire

Si p est un pointeur sur une variable de type arbre, p^ est la variable pointée par
p. cette variable est un enregistrement, pour accéder à ses champs on utilise
l’opérateur "." .
 p^. valeur
 p^. filsg
 p^. filsd

5.3. Insertion d’un nœud d’une valeur v dans un arbre binaire

Principe

Créer un nœud d’adresse n contenant la valeur v et dont le sous arbre gauche

est g et le sous arbre droit est d.

Algorithme

Fonction CA (G : ^arbre, val : caractere, D :^arbre ): ^arbre

Variable
n : ^arbre
Debut
nnouveau(^arbre)
n^.valeurval
n^.filsgG
n^.filsdD
CAn
fin

5.4. Parcours d’un arbre binaire

5.4.1. Parcours Prefixe

PROCEDURE Prefixe(racine : ^arbre)

debut
si (racine<>Nil ) alors
ecrire(racine^.valeur)
Prefixe(racine ^.filsg)
Prefixe(racine ^. filsd)
finsi
fin

5.4.2. Parcours Infixe

PROCEDURE Infixe (racine : ^arbre)

-35-
 ‎5.5. Tester si un Nœud est une feuille

debut
si (racine<>Nil ) alors
Infixe(racine ^.filsg)
ecrire(racine^.valeur)
Infixe(racine ^. filsd)
finsi
fin

5.4.3. Parcours Postfixé

PROCEDURE Postfixe (racine : ^arbre)

debut
si (racine<>Nil ) alors
Postfixe(racine ^.filsg)
Postfixe(racine ^. filsd)
ecrire(racine^.valeur)
finsi
fin

5.5. Tester si un Nœud est une feuille

Fonction estfeuille (r : ^arbre) : entier

debut
si (r ^. filsg=Nil et r^.filsd=Nil) alors
estfeuille1
Sinon
estfeuille0
finsi
fin

5.6. Nombre de feuilles dans un arbre binaire

Fonction nbfeuille (r : ^arbre) : entier

debut
si (r=nil) alors
nbfeuille 0
Sinon
nbfeuille  estfeuille(r)+nbfeuille(r^.filsg)+nbfeuille(r^.filsd)
finsi
fin

-36-
 ‎6.1. Définition

Chapitre 6

Les arbres binaires de recherche

6.1. Définition

Un Arbre Binaire de Recherche (ABR) A est dit de recherche ssi : si v est la

valeur portée par un nœud N de l’arbre A alors
1) v est supérieure a toutes les valeurs présentes dans le sous arbre gauche de N
2) v est inférieure à toutes les valeurs présentes dans le sous arbre droite de N

4 9

1 5

Figure ‎6.1-un arbre binaire de recherche

6.2. Ajout d’une valeur dans un ABR

Ecrire la procédure Ajout qui permet d’ajouter une valeur v à un arbre binaire
de recherche donné par l’adresse de sa racine r.

-37-
 ‎6.2. Ajout d’une valeur dans un ABR

4 9

1 5

Figure ‎6.2-L’ ABR avant l’ajout de la valeur 6

4 9

1 5

Figure ‎6.3-L’ ABR aprés l’ajout de la valeur 6

Principe

1) si l’arbre est vide

 Créer un Nœud n contenant la valeur V
nnouveau(^arbre)
n^.valeurv
n^.filsgNil
n^.filsdNil
 alors la racine est n
racinenouveau(^arbre)
2) sinon
 si la valeur portée par la racine est supérieure ou égale à V alors
l’insertion se fait dans le sous arbre droit
Ajout(racine^.filsd. v)
 sinon l’insertion se fait dans le sous arbre gauche

-38-
 ‎6.3. Recherche d’une valeur dans un ABR

Ajout(racine^. filsg.v)

Algorithme

PROCEDURE Ajout(var r : ^arbre , v : entier )

debut
si(r=Nil) alors
rnouveau(^arbre)
r^.valeurv
r^.filsg  Nil
r^. filsd  Nil
sinon
si(v<r^.valeur)
Ajout(r^. filsg,v)
sinon
Ajout(r^. filsd,v)
finsi
finsi
fin

6.3. Recherche d’une valeur dans un ABR

Ecrire la fonction Rcherche qui permet de renvoyer l’adresse du nœud qui

contient une valeur v dans un ABR donné par l’adresse de sa racine (racine).

Principe

1) si l’arbre est vide la fonction renvoie le Nil

Si (racine=Nil) alors
RechercheNil
2) Sinon, si la valeur porté par le Nœud en cours = V , en renvoie la racine
Sinon
si(racine^.valeur=v) alors
Rechercheracine
3) Sinon, si la valeur porté par le Nœud en cours < V , la recherche se fait dans le
sous arbre gauche
sinon
si(racine^.valeur<v) alors
Recherche Recherche (racine^.filsg, v)
3) Sinon, la recherche se fait dans le sous arbre droite

-39-
 ‎6.4. Recherche du nœud père d’une valeur dans un ABR

sinon
Recherche Recherche (racine^.filsd, v)
finsi
finsi
finsi

Algorithme

Fonction Recherche( r : ^arbre , v : entier ) : ^arbre

Debut
Si (racine=Nil ou racine^.valeur=v) alors
Rechercheracine
sinon
si(racine^.valeur>v) alors
Recherche Recherche (racine^.filsg)
sinon
Recherche Recherche (racine^.filsd)
finsi
finsi
fin

6.4. Recherche du nœud père d’une valeur dans un ABR

Ecrire la fonction Pere qui permet de renvoyer l’adresse du nœud père du nœud
qui contient une valeur v dans un arbre binaire de recherche donné par l’adresse
de sa racine (racine).

Algorithme

Fonction Pere ( r : ^arbre , v : entier ) : ^arbre

Debut
Si(r=Nil ou r^.valeur=v) alors
PereNil
sinon
si(r^.filsg et r^.filsg^.valeur=v)alors
Perer
sinon
si(r^.filsd et r^.filsd^.valeur=v)alors
Perer
sinon
si(v<r^.valeur) alors
Pere Pere(r^.filsg,v)
sinon

-40-
 ‎6.5. Recherche du max d’un ABR

Pere Pere(r^.filsd,v)
finsi
finsi
finsi
finsi
fin

6.5. Recherche du max d’un ABR

Ecrire la fonction maxarb qui permet de renvoyer l’adresse du nœud contenant

la plus grande valeur dans un arbre binaire de recherche donné par l’adresse de sa
racine (racine).

Algorithme

Fonction maxarb ( r : ^arbre ) : entier

Debut
Si(r^.filsd=Nil)alors
maxarbr^.valeur
sinon
maxarb maxarb (r^.filsd)
finsi
fin

6.6. Suppression d’une valeur dans un ABR

Ecrire la PROCEDURE Supv qui permet de supprimer une valeur v dans un arbre
binaire de recherche donné par l’adresse de sa racine (r).

Principe :

1 ) si le nœud à supprimer n’est pas la racine

1.1) si le nœud v est une feuille,

 On cherche le nœud f qui porte la valeur v
 On cherche père de v (p)
 on met à jours les pointeurs de p
 On libère f

-41-
 ‎6.6. Suppression d’une valeur dans un ABR

4 9

1 5

1.2) si le nœud v possède un seul fils:

 On cherche le nœud f qui porte la valeur v
 On cherche père de v (p)
 On met à jours les pointeurs de p
 On libère f

4 9

1 5

1.3) si le nœud V possède deux fils :

 On cherche le nœud f qui porte la valeur v
 On cherche le max dans le sous arbre gauche
 On écrit max à la place de v
 On supprime max dans le sous arbre gauche

-42-
 ‎6.6. Suppression d’une valeur dans un ABR

4 9

1 5

2 ) si le nœud à supprimer est pas la racine

2.1) si racine est une feuille

 On libère racine
2.2) si racine possède un seul fils:
 On met à jours racine
 On libère l’ancienne racine

1 5

2.3) si la racine possède deux fils:

 On cherche le max dans le sous arbre gauche
 On remplace la valeur porté par racine par max
 on supprime max su sous arbre gauche

-43-
 ‎6.6. Suppression d’une valeur dans un ABR

4 9

1 5

Algorithme

PROCEDURE Supv( var r :^arbre, v : entier)

variable
f,p : ^arbre
max :^entier
debut
fRecherche(r, v)
si (f=Nil) alors // v est inexistante dans l’arbre
ecrire("valeur", v, "inexistante dans l'arbre")
Sortir
finsi

Si(p=Nil) alors// on supprime la racine

si (estfeuille(f)) alors // 0 fils
Liberer(r)
sortir
finsi
si(!f->filsg et f^.filsd) alors// 1 fils a droite
rr^.filsd
Liberer(f)
sortir
finsi
si (f^.filsg et !f^.filsd) alors// 1 fils à gauche
rr^ .filsg
Liberer(f)
sortir
finsi
// 2 fils
Maxmaxarb(f^.filsg)
f^.valeurmax
Supv(f^.filsg, max)
sortir
finsi
ppere(r,v)

-44-
 ‎6.6. Suppression d’une valeur dans un ABR

si(estfeuille(f))alors // 0 fils
si(p^.filsg et p^.filsg^.valeur=v) alors
p^.filsgNIL
Liberer(f)
sortir
sinon

p^.filsdNIL
Liberer(f)
sortir
finsi
finsi
fin

-45-
 ‎7.1. Introduction

Chapitre 7

Introduction à la complexité

7.1. Introduction

Différents algorithmes peuvent être proposés pour résoudre un même

problème. par exemple le tri d’un tableau : par sélection, à bulle, etc. afin de
comparer ces algorithmes nous nous basons sur leurs efficacités.
L’efficacité d’un algorithme revient à mesurer les ressources consommées par
ce dernier. Principalement ces ressources sont : CPU (temps d’exécution) et
mémoire centrale.
Dans le cadre de ce cours, nous nous intéressons seulement à l’aspect temps
d’exécution. Le temps d’exécution d’un algorithme est calculé en fonction du
nombre d’instructions élémentaires qui le forment et dépend des instances du
problème. Ce nombre est appelé la complexité de l’algorithme.

7.2. Les opérations élémentaires et notion d’instance

Nous appelons opérations élémentaires :

 un accès en mémoire pour lire ou écrire la valeur d’une variable ou d’une
case d’un tableau ;
 une opération arithmétique entre entiers ou entre réels : addition,
soustraction, multiplication, division, calcul du reste dans une division
entière ;
 une comparaison entre deux entiers ou deux réels.

Exemple :

si on considère l’instruction xa + b, on peut compter 4 opérations

élémentaires :
 l’accès en mémoire pour lire la valeur de a,
 l’accès en mémoire pour lire la valeur de b,
 l’addition de a et b,
 l’accès en mémoire pour écrire la nouvelle valeur de x.
Pour un problème donné, on appelle instance tout jeu de données de ce
problème. Par exemple, pour un problème de tri, on obtient une instance en
spécifiant la valeur numérique des nombres à trier.

-46-
 ‎7.3. Définition

7.3. Définition

On considère un algorithme A. On appelle complexité de A tout ordre de grandeur

du nombre d’opérations élémentaires effectuées pendant le déroulement de
l’algorithme. Cet ordre de grandeur est noté O.

Exemple

On note O(n) pour exprimer que le nombre d’instructions d’ordre n, avec n la

taille des données (instance de A)

Exemple de fonction

FONCTION SOMME( t :vecteur, n: entier) : entier

variable
s,i : entier
Debut
S0
i1
tantque(i<=n) faire
ss+t[i]
ii+1
fin tantque
SOMMEs
fin
Le nombre instructions élémentaires :
 affectation : 2+2*n+1
 comparaison : n
 addition : 2*n
 l’accès en mémoire : n
La complexité de cette fonction, notée f(n) :
f(n)=5n+3 qui de l’ordre de n qui noté O(n)

7.4. Calculs élémentaires de complexité

Le calcul de la complexité dépend des structures conditionnelles et itératives.

Nous donnons l’évaluation de la complexité pour chacune de ces structures.

7.4.1. Si...Sinon

 Si I1 est une suite d’instructions en O( f1),

 I2 est une suite d’instructions en O( f2) et
 T est un test en O(g),
alors

-47-
 ‎7.5. Exemple : le tri par insertion

si (T) alors
{I1}
Sinon
{I2}
finsi
est en O(max{ f1, f2}+g), De manière similaire : Si (T) {I1} est en O( f1+g)

7.4.2. La boucle pour

pour i de a à b faire
ACTION(i ),
finpour
si f (i) désigne le coût de l’exécution de ACTION(i ), alors le coût de la boucle
est : ∑𝑏𝑖=𝑎 𝑓(𝑖)

7.4.3. La boucle tantque

Tantque(C(x) faire
Action(x)
fintantque
 xi la valeur quelle prend C dans chaque étape
 0≤i≤k
 g(xi ) le coût de la condition C(xi )
 f (xi ) le coût de l’action ACTION(xi )
alors le coût de la boucle est : ∑𝑘𝑖=0 𝑓(𝑥𝑖 ) + ∑𝑘+1
𝑖=0 𝑔(𝑥𝑖 )

7.5. Exemple : le tri par insertion

PRODECURE Tri_Insertion (T : vecteur, n : entier)

Variable
v, i,j : entier
debut
pour i de 2 à n faire
v T [i]
ji
tantque(T [j-1]>v) faire
T [j] T [j-1]
jj-1
fintantque
T [j]v
finpour
fin

-48-
 ‎7.5. Exemple : le tri par insertion

Evaluation de la complexité de la boucle :

ji
tantque(T [j-1]>v) faire//g(xi)
T [j] T [j-1]// f(xi)
jj-1
fintantque
Le coût de la boucle est : 𝑓1(𝑖) = ∑𝑖−1 𝑖
𝑗=1 𝑓(𝑥𝑖 ) + ∑𝑗=1 𝑔(𝑥𝑖 )

𝑓(𝑥𝑖 ) = 1 + 1 + 1 + 1 = 4

𝑖−1

∑ 𝑓(𝑥𝑖 ) = 4(𝑖 − 1) 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑖)

𝑗=1

𝑔(𝑥𝑖 ) = 1 + 1 = 2

∑ 𝑔(𝑥𝑖 ) = 2𝑖 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑖)

𝑗=1

𝑖−1 𝑖

𝑓1(𝑖) = ∑ 𝑓(𝑥𝑖 ) + ∑ 𝑔(𝑥𝑖 ) 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑖)

𝑗=1 𝑗=1

Evaluation de la complexité de la boucle pour :

Le coût de la boucle est :

𝑛
𝑛−2
∑ 𝑓1(𝑖) = 2 + 3+. . 𝑛 = (𝑛 − 1) ∗ 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑛2 )
2
𝑖=2

-49-
 Série 1 : Enoncé

Série 1 : Enoncé

Exercice 1 :

Définir les types maillon et liste permettant de manipuler une liste de nombres
réels

Exercice 2 :

Ecrire la procédure inserttete (ajout en tête de liste) qui permet d’ajouter une
valeur val au début d’une liste chaînée.

Exercice 3:

Ecrire la procédure affichelist1 qui affiche le contenu de la liste selon la

présentation suivante :

premier 1.3 4 2.5 2.7 5.2

La procédure affiche : 1.3 4 2.5 2.7 5.2

Exercice 4:

Ecrire la procédure affichelist2 qui affiche le contenu de la liste selon la

présentation suivante :

premier 1.3 4 2.5 2.7 5.2

La procédure affiche : 5.2 2.7 2.5 4 1.3

Exercice 5 :

Ecrire une fonction récursive qui permet de renvoyer vrai si un réel val existe
dans une liste chaînée donnée par l’adresse de son premier élément faux si non.

Exercice 6 :

Ecrire une fonction qui permet de renvoyer le nombre d’apparition d’un entier
val dans une liste chaînée donnée par l’adresse de son premier.

Exercice 7 :

Ecrire une procédure qui permet de calculer l’intersection de deux listes dans
un troisième.

-50-
 Série 1 : correction

Série 1 : correction

Exercice 1 :

type maillon= enregistrement

valeur : réel
suivant : ^maillon
finenregistrement

type liste=maillon

Exercice 2 :

PROCEDURE InsertTete (var premier : ^liste, val : entier)

variable
p1 : ^liste
debut
p1nouveau(^liste)
p1^.valeurval
p1^.suivant premier
premierp1
fin

Exercice 3:

PROCEDURE affichelist1 (premier : ^liste)

debut
si(premier<>nil) alors
affichelist1(premier^.suivant)
ecrire(premier^. Valeur)
finsi
fin

Exercice 4:

PROCEDURE affichelist2 (premier : ^liste)

debut
si(premier<>nil) alors
ecrire(premier^. Valeur)
affichelist2(premier^.suivant)
finsi
fin

Exercice 5 :

FONCTION existe (premier : ^liste, val :réel) :booléen

debut
-51-
 Série 1 : correction

si(premier=nil) alors
existefaux
sinon
si(premier^.valeur=val) alors
existevrai
sinon
existeexiste(premier^.suivant)
finsi
finsi
fin

Exercice 6 :

FONCTION nbocc (premier : ^liste, val :réel) : entier

debut
si(premier=nil) alors
nbocc 0
sinon
si(premier^.valeur=val) alors
nbocc 1+nbocc(premier^.suivant)
sinon
nbocc  nbocc (premier^.suivant)
finsi
finsi
fin

Exercice 7 :

PROCEDURE intersection (p1 : ^liste, p2 :^liste, var p3 :^liste)

si(p1<>nil) alors
si(existe(p2,p1^valeur)et non (existe(p2,p1^valeur))) alors
inserttete(p3,p1^.valeur)
finsi
intersection(p1^.suivant,p2,p3)
finsi
fin

-52-
 Série 2: Enoncé

Série 2: Enoncé

Une chaîne de bits b (b = bn−1 … b0 ) de longueur n ≥ 1 est représentée par une

liste chaînée de bits où la tête représente le bit de poids fort (bn−1), dont la
définition est la suivante :
type maillon = Enregistrement
Valeur : entier
Suivant : ^maillon
FinEnregistrement
type Liste =maillon
Par exemple le nombre binaire 11010 est représenté par la liste L1.

L1 1 1 0 1 0

Exercice 1 :

Ecrire la fonction InsertTete qui permet d’insérer une valeur val en tête d’une
liste donnée par l’adresse de son premier maillon.

Exercice 2 :

Donner les instructions pertmettant de construire la liste L1 de l’exemple

11010).

Exercice 3 :

La valeur, notée ValChainel(b) d’une chaîne de bits de longueur n ≥ 1 est le

nombre naturel dont la représentation binaire est cette chaîne. Par exemple :
ValChaine(00001111) = 15 et ValChaine(01010101) = 85
La fonction val est dénie par l'expression suivante :

𝑛−1

𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(𝑏𝑛−1 … 𝑏0 ) = ∑ 𝑏𝑖 ∗ 2𝑖
𝑖=0
Donner 𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(1101) et 𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(111101).

Exercice 4 :

Ecrire la fonction récursive puissance qui permet pour deux entiers n ≥ 0 et

m ≥ 1 de renvoyer mn .

-53-
 Série 2: Enoncé

Exercice 5 :

Ecrire la fonction récursive LongListe qui renvoie le nombre d’éléments d’une

liste donnée par l’adresse de son premier maillon.

Exercice 6 :

Ecrire la fonction valChaine qui accepte une liste donnée par l’adresse de son
premier maillon et renvoie la valeur de la chaîne représentée par cette liste.
Par exemple :
𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(11010) = 26

Exercice 7 :

La distance de Hamming, notée H(c, d) entre deux chaînes de bits c et d de

longueur n ≥ 1 est le nombre de positions où les bits correspondants sont
différents.
Par exemple :
𝐻(00001111,01010101) = 4
Ecrire la fonction H qui accepte deux listes données par les adresses de leurs
premiers maillons et renvoie la distance de Hamming entre les deux chaînes
représentées par ces deux listes.

Exercice 8 :

Deux chaînes de bits c et d sont dits adjacents s'ils sont à une distance de
Hamming de 1.
Ecrire la fonction Adjacents qui accepte deux listes données par les adresses de
leurs premières maillons et renvoie 1 si c et d sont adjacents, 0 sinon.

-54-
 Série 2: correction

Série 2: correction

Exercice 1 :

PROCEDURE InsertTete (var first : ^Liste, , val : entier)

variable
p1 : ^Liste
debut
p1nouveau(Liste)
p1^.valeurval
p1^.suivantp
pp1
fin

Exercice 2 :

first : ^Liste
Firstnil;
InsertTete(first,0)
InsertTete(first,1)
InsertTete(first,0)
InsertTete(first,1)
InsertTete(first,1)

Exercice 3 :

𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(1101) = 13 𝑉𝑎𝑙𝐶ℎ𝑎𝑖𝑛𝑒(111101) = 59.

Exercice 4 :

Fonction puissance (n : entier, m : entier) : entier

debut
si(n=0)alors
puissance 1
sinon
puissance  m*puissance(n-1,m)
finsi
fin

Exercice 5 :

Fonction LongListe (first : ^Liste) : entier

debut
si(first =Nil)alors

-55-
 Série 2: correction

LongListe 0
sinon
LongListe  1+LongListe(first^.suivant)
finsi
fin

Exercice 6 :

Fonction valChaine (first : ^Liste) : entier

Variable
l,v : entier
debut
v0
pour l de LongListe(first) a 1 pas de -1 faire
vv+first^.valeur*puissance(l-1,2)
first=first^.suivant
finpour
valChaine v
fin

Exercice 7 :

Fonction H (first1 : ^Liste, first2 : ^Liste) : entier

Variable
nb : entier
debut
nb0;
tantque(first1<>Nil) faire
si(first1^.valeur<>first2^.valeur) alors
nbnb+1
finsi
first1first1^.suivant
first2first2^.suivant
fintantque
Hnb
fin

Exercice 8 :

Fonction Adjacents (first1 : ^Liste, first2 : ^Liste) : entier

debut
si(H(first1,first2)=1)alors
Adjacents 1
sinon
Adjacents 0
finsi
fin

-56-
 Série 3 : Enoncé

Série 3 : Enoncé

Exercice 1
Définir la structure de donnée qui permet de d’implémenter le type liste
doublement chainée listedc.
Exercice 2
Ecrire la fonction LongListe qui accepte un pointeur sur la tête d’une liste
doublement chainée first et renvoie la longueur de la liste.
Exercice 3
Ecrire la fonction LongListeApres qui accepte un pointeur sur une liste
doublement chainée p et renvoie le nombre des maillons après le maillon pointé
par p.
Exercice 4
Ecrire la fonction LongListeAvant qui accepte une pointeur sur une liste
doublement chainée p et renvoie le nombre des maillon après le maillon pointé par
p.
Exercice 5
La base 2 est une méthode de représentation des nombres qui n’utilise que les
deux chiffres, 0 et 1 (alors que la base 10 utilise en utilise dix, 0, 1, 2, 3, 4, 5, 6, 7, 8
et 9).
Pour transformer un nombre écrit en base 10 en un nombre écrit en base 2, il
suffit d’effectuer des divisions successives par 2 en prenant à chaque fois le
quotient de la division précédente comme dividende (sauf pour la première fois ou
le dividende est le nombre donné). On arrête ces divisions si le dividende est égale
à 0.
Les restes successifs de ces divisons sont alors la représentation inverse du
nombre de départ.
Par exemple la représentation en base 2 de 13 est 1101
1. Donner la représentation en base 2 de 34.
2. Ecrire la procédure InsertTete qui permet d’insérer une valeur val en tête d’une
liste doublement chainée donnée par l’adresse de son premier maillon.
3. Ecrire la fonction Covert2To10 qui accepte un entier n et renvoie la liste
doublement chainée contenat la représentation de n dans la base 2.
4. Ecrire la procédure AfficheListe qui permet d’afficher une liste doublement
chainée donné par le premier maillon
5. Ecrire un algorithme qui permet de saisir un entier n strictement positif puis il
affiche sa représentation en base 2.

-57-
 Série 3: correction

Série 3: correction

Exercice 1
type maillon= enregistrement
valeur : entier
suivant : ^maillon
precedent : ^maillon
finenregistrement

type listedc=maillon

Exercice 2
Fonction LongListe (first :^ listedc) : entier
variable
l : entier
debut
l0
tantque(p) faire
l++
pp^.suivant
fintanque
LongListe l
fin
Exercice 3
Fonction LongListeApres (p :^ listedc) : Entier
variable
l : entier
debut
l0
tantque(p) faire
l++
pp^.suivant
fintanque
LongListeApres l
fin
Exercice 4
Fonction LongListeAvant (p :^ listedc) : Entier
variable
l : entier
debut
l0
tantque(p) faire

-58-
 Série 3: correction

l++
pp^.precedent
fintanque
LongListeAvant l
fin
Exercice 5
1. .
100010
2.
PROCEDURE InsertTete (var first : ^ listedc, val : entier)
variable
p1 : ^listedc
debut
p1nouveau(^listedc)
p1^.valeurval
p1^.suivantp
p1^.precedentNil
si(p)alors
p^.precedentp1
finsi
pp1
fin
3.
Fonction Covert2To10 (n : entier) :^listedc
variable
p : ^listedc
r,q : entier
debut
pnil
qn
repéter
r  q mod 2
qq div 2
InsertTete(p,r)
jusqu’à(q=0)
Covert2To10 p
fin
4.
PROCEDURE AfficheListe (p : ^listedc )
debut
tantque(p<>nil) faire
ecrire(p^.valeur)
pp^.suivant
fintantque
fin

-59-
 Série 3: correction

5.
Algorithme conversion
//déclarations des types
// définitions des fonctions et des procédures
variable
p : ^listedc
n : entier
debut
pNil
ecrire("n=?")
lire(n)
pCovert2To10(n)
AfficheListe(p)
fin

-60-
 Série 4 : Enoncé

Série 4 : Enoncé

Exercice 1
Définir la structure de donnée qui permet de d’implémenter le type arbre.
Exercice 2
Ecrire la fonction taille qui permet de renvoyer le nombre de nœud dans un
arbre donné par sa racine r
Exercice 3
Ecrire la fonction père qui permet de renvoyer le nœud père d’un nœud n dans
un arbre donné par sa racine r.
Exercice 4
La profondeur d’un nœud n est la longueur du chemin qui va de la racine à ce
nœud.
Ecrire la fonction profondeur qui permet de renvoyer la profondeur d’un nœud
N dans un arbre donné par sa racine r.
Exercice 5
La hauteur d’un arbre est un de plus que la longueur du plus long chemin de la
racine à une feuille. Un arbre vide est de hauteur 0.
Ecrire la fonction hauteur qui permet de renvoyer la hauteur d’un arbre donné
par sa racine r.

-61-
 Série 4: correction

Série 4: correction

Exercice 1
type nœud = enregistrement
v: entier
filsg : ^ nœud
filsd : ^ nœud
finenregistrement

type arbre= nœud

Exercice 2
FONCTION taille (r :^arbre) :entier
debut
si(r=nil) alors
taille0
sinon
taille1+ taille(r^.filsg)+taille(r^.filsd)
finsi
fin

Exercice 3

FONCTION pere (r:^arbre, n:^arbre) :^arbre

debut
si(r=nil ou r=n) alors
pere nil
sinon
si(r^.filgs=n ou r^.filgs=n) alors
pèrer
sinon
si(père(r^.filsg,n) alors
père père(r^.filsg,n)
sinon
père père(r^.filsd,n)
finsi
finsi
finsi
fin

Exercice 4
FONCTION profondeur (r :^arbre, n:^arbre) : entier
debut
si(père(r,n)=nil) alors
-62-
 Série 4: correction

profondeur0
sinon
profondeur1+ profondeur(r, père(r,n))
finsi
fin
Exercice 5
FONCTION hauteur (r:^arbre) : entier
debut
si(r=nil) alors
hauteur 0
sinon
hauteur 1+max(hauteur(r^.filsg),hauteur(r^.filsd))
finsi
fin

-63-
 Série 5 : Enoncé

Série 5 : Enoncé

Exercice 1
Donner l’arbre binaire de recherche obtenu après l’insertion successive des
valeurs :7, 4, 5, 1 et 9
Exercice 2
Donner tous les arbres binaires de recherche qui contiennent les valeurs 1, 2 et
3.
Exercice 3

4 9

1 5

Donner l’arbre binaire de recherche obtenu après l’insertion de la valeur 17

dans l’arbre ci-dessous.
Exercice 4

4 9

1 5

Donner l’arbre binaire de recherche obtenu après la suppression de la valeur 4

de l’arbre ci-dessous.
Exercice 5

-64-
 Série 5 : Enoncé

4 9

1 5

Donner l’arbre binaire de recherche obtenu après la suppression de la valeur 7

de l’arbre ci-dessous.
Exercice 6
Ecrire la fonction existe qui renvoie vrai si une valeur val est présente dans un
l’arbre binaire de recherche et renvoie faux si non.
Exercice 7
Ecrire la fonction ABR qui accepte un arbre et renvoie vrai si l’arbre est binaire
de recherche si non la valeur fausse.

-65-
 Série 5: correction

Série 5: correction

Exercice 1

4 9

1 5

Exercice 2

A1

1 3

A2

-66-
 Série 5: correction

A3

Exercice 3

4 9

1 5 17

Exercice 4

5 9

Exercice 5

-67-
 Série 5: correction

4 9

Exercice 6
FONCTION existe (r:^arbre, val : réel) : booléen
Debut
si(r<>nil) alors
existefaux
sinon
si(r^.valeur=val) alors
existevari
sinon
si(r^.valeur>val) alors
existe existe(r^.filsg)
sinon
existe existe(r^.filsd)
finsi
finsi
finsi
fin
Exercice 7
FONCTION ABR (r:^arbre) : booléen
debut
si(r=nil ou estfeuille(r)) alors
ABR vari
sinon
si(r^.filsg et r^.filsd) alors// deux fils
si(r^.valeur>r^.filsg^.valeur et r^.valeur<r^.filsd^.valeur)
alors
ABRABR(r^.filsg) et ABR(r^.filsd)
sinon
ABRfaux
finsi
sinon
si(r^.filsg et r^.filsd=nil) alors//1 fils à gauche
si(r^.valeur>r^.filsg^.valeur) alors
ABRABR(r^.filsg)
sinon

-68-
 Série 5: correction

ABRfaux
Finsi
sinon
si(r^.valeur<r^.filsd^.valeur) alors1 filsà droite
ABRABR(r^.filsd)
sinon
ABRfaux
finsi
finisi
finsi
fin

-69-