Présentation Compléments Algo

Cours: Compléments
Algorithmique
LOYA Youssouf
youssouf.loya@u-auben.com
1
Objectif
Le cours vise à donner aux étudiants des
connaissances sur les structures de données
classiques.
A l’issue du cours, les étudiants sont être capables
de :
 maîtriser les différentes méthodes classiques d’
organiser les données : tableaux, listes, files, piles.
 mettre en œuvre ces structures à travers les
différents algorithmes, et de nombreux exemples
d’application.
2
Plan
 Tableaux
 Types de données dérivés
 Structures de données linéaires
3
Prérequis
 Cours Introduction à l’algorithmique

(Structures de contrôle, sous-programmes,
tableaux)
4
Tableaux
Introduction
 Motivation
 Définition
Tableaux à une dimension
 Généralités
 Traitements simples
 Algorithmes de tri
 Algorithmes de recherche
Fusion de tableaux triés
Applications
Tableaux à deux dimensions
Généralités
 Applications 5
Introduction
Motivation
Imaginons que dans un algorithme, on ait besoin
simultanément des notes d’un étudiant dans 12 matières
afin de leur appliquer diverses manipulations (calculer leur
moyenne, rechercher leur maximum et leur minimum, etc.)
A l’état actuel de nos connaissances, la solution
consisterait à:
déclarer 12 variables représentant ces notes n1, n2, n3,
n4, n5, n6, n7, n8, n9, n10, n11, n12 car chaque note
peut participer à plusieurs calculs;
lire chacune des 12 variables ;
calculer la moyenne par la formule:
(n1+n2+n3+n4+n5+n6+n7+n8+n9+n10+n11+n12)/12
... 6
Introduction
Motivation
La solution est fastidieuse, et cela allait se compliquer
davantage si le nombre de matières était plus élevé ou
inconnu à l’avance.
Une idée, en algorithmique, pour résoudre ce problème est
de rassembler toutes ces variables en une seule, au sein
de laquelle chaque variable sera repérée par un numéro.
Cela permettra de simplifier la déclaration de ces variables
et leur manipulation grâce aux boucles.
7
Introduction
Définition
Jusqu’ici, on a utilisé les variables pour les valeurs
individuelles de types de base;
Les tableaux vont permettre de regrouper plusieurs valeurs
de même type dans une seule variable.
Un tableau est une variable formée d’un nombre fini de
variables contiguës de même type appelées
composantes ou éléments du tableau.
Un tableau possède un nom, un type et un nombre
maximal d’éléments qui représente sa taille. La taille d’un
tableau est fixe c’est-à-dire une expression constante.
On peut former des tableaux de réels, d’entiers, de
caractères, d’enregistrements ou de tableaux.
8
Tableaux à une dimension
Généralités
 Définition
Un tableau à une dimension ou vecteur ou encore liste est
un tableau dont les éléments ne sont pas des tableaux.
Le type commun des éléments d’un tableau est appelé
type du tableau.
Chaque élément d’un tableau à une dimension est repéré
par sa position, dans le tableau appelée indice.
a u e nt d e r a ng
bl e nt e l ’é l ém
du ta t t e c a se r e p r é s e
Nom Ce
1 2 3 3 4 5 6 7
temperature
25 30 34 36 33 22 27
9
Généralités
 Déclaration
Un tableau à une dimension est déclaré par la syntaxe:
VAR
<nom_tableau> : TABLEAU[<taille>] DE <type_elts>;
Cette syntaxe déclare <nom_tableau> comme un tableau
de <taille> éléments de type <type_elts>
TABLEAU[<taille>] DE <type_elts> est le type tableau de
<taille> <type_elts>.
 Exemple: VAR notes : TABLEAU [12] DE REEL ;
Cette déclaration va réserver en mémoire une zone nommée notes constituée
de 12 emplacements contigus destinés à contenir chacun des réels.
Remarque: Pour faciliter l’évolution des programmes, il est
conseillé de définir les tailles des tableaux sous forme de
constantes explicites, à l’aide de symboles. 10
Généralités
 Accès aux éléments d’un tableau
L’accès à un élément d’un tableau permet de traiter cet
élément comme n’importe quelle variable individuelle :
modifier sa valeur, l’utiliser dans un calcul, l’afficher, . . .
L’accès à un élément se fait en faisant suivre le nom du
tableau de l’indice de l’élément entre crochets [ ] :
<nom_tableau>[<indice>]
<indice> peut être :
− une valeur entière représentant la position de l’élément ;
− une variable entière contenant la position de l’élément ;
− une expression entière dont la valeur donne la position de
l’élément.
<indice> doit être compris entre 1 et la taille du tableau.
11
Généralités
Exemple :
VAR notes : TABLEAU [12] DE REEL ;
i : ENTIER ;
notes[1]¬ 10.5 ; (* affecter 10.5 au premier élément *)
i¬5 ;
LIRE(notes[i]) ; (* lire l’élément d’indice i *)
ECRIRE(notes[2*i+1]) ;(*afficher la valeur de l’élément d’indice 2*i+1 *)
Remarque:
Il ne faut pas confondre l’indice i d’un élément et sa
valeur notes[i].
Un tableau peut avoir des éléments dont la valeur est
indéterminée, donc avant d’utiliser un tableau il faut
l’initialiser.
12
Généralités
Remarque:
Le nombre d’éléments d’un tableau ayant des valeurs
déterminées est inférieur ou égal à la taille du tableau,
autrement dit on peut déclarer un tableau de dix
éléments et n’en utiliser réellement que cinq.
 Le fait que les éléments constituant un tableau soient
indicés permet de parcourir tous les éléments avec une
boucle.
 Remplissage de tableau
Le remplissage d’un tableau consiste à renseigner les différents
éléments du tableau soit par lecture soit par affectation.
13
Généralités
 Remplissage de tableau
Exemple: Ecrire une procédure qui lit les n notes d’un étudiant.
On suppose
CONST qu’un étudiant ne peut avoir plus de 12 notes.
NBMAX12:ENTIER;
PROCÉDURE chargement (S notes : TABLEAU[NBMAX] DE REEL, E n :ENTIER)
(* précondition: n≤ NBMAX *)
VAR i : ENTIER;
DÉBUT
POUR i DE 1 À n FAIRE
ECRIRE(Entrer la note , i) ;
LIRE (notes[i]);
FINPOUR
FIN
Remarque:
 Si n< NBMAX, on dit que le remplissage est partiel, sinon qu’il
est complet.
 Le remplissage d’un tableau peut être fait en désignant
directement, par leurs indices, les éléments à renseigner et 14
ce
Généralités
 Affichage de tableau
L’affichage d’un tableau consiste à parcourir les éléments du
tableau ayant des valeurs déterminées et à afficher leurs
contenus.
Exemple: Ecrire une procédure qui édite les notes d’un étudiant
précédemment saisies.
On suppose
CONST qu’un étudiant ne peut avoir plus de 12 notes.
NBMAX12:ENTIER;
PROCÉDURE affichage(E notes : TABLEAU[NBMAX] DE REEL, E n :ENTIER)
(* précondition: n≤ NBMAX *)
VAR i : ENTIER;
DÉBUT
ECRIRE(notes[i], ) ;
FINPOUR
FIN
15
Généralités
 Définition de type tableau
En algorithmique, on définit un type tableau par:
TYPE
<nom_type> = TABLEAU[<taille>] DE
<type_elts> ;
Exemple:
CONST NBMAX12: REEL;
TYPE
NOTE = TABLEAU [NBMAX] DE REEL;(* NOTE : ensemble des
tableaux de 12 réels *)
VAR
notes : NOTE ; (* notes : tableau de 12 réels *)
16
Traitements simples
 Insertion d’une valeur à une position donnée
Il s’agit d’insérer un élément à une position donnée dans un
tableau.
Principe
 Vérifier que le tableau n’est pas plein (nombre éléments< taille);
 Décaler vers la droite tous les éléments du tableau, s’ils
existent, situés à droite de la position d’insertion (y compris
l’élément qui se trouve à la position d’insertion) en
commençant par l’élément le plus droite ;
 Insérer la valeur à la position dégagée ;
 Incrémenter éventuellement le nombre effectif d’éléments du
tableau.
Exemple
Ecrire un algorithme qui ajoute à une position donnée une note
aux notes déjà saisies d’un étudiant. 17
ALGORITHME Insertion
CONST NBMAX 12 : ENTIER ; (* taille du tableau qui doit être fixe *)
TYPE NOTE = TABLEAU [NBMAX] DE REEL ; (* définition de type tableau *)
Traitements
VAR notes : simples
NOTE; (* tableau des notes *)
 Insertion
n : ENTIER
d’une ; (* nombre à
valeur effectif
une deposition
i : ENTIER ; (* compteur de notes *)
notes de l’étudiant
donnée *)
Exempleno : REEL ; (* note à insérer *)
pos : ENTIER ; (* position d’insertion *)

DEBUT
SI (n<NBMAX) ALORS (* s’il y a de la place dans le tableau *)
(* Lecture de la position d’insertion *)
REPETER
ECRIRE(Entrer la position d’insertion: ) ;
LIRE(pos) ;
JUSQU'A (pos1 ET pos n+1)
(* Lecture de la note à insérer *)
ECRIRE(Entrer la note à insérer :) ;
LIRE(no) ;
(* Décalage vers la droite des éléments du tableau *)
POUR i DE n A pos PAS DE -1 FAIRE
notes[i+1] notes[i];
FINPOUR
(* Insertion de la note no dans le tableau à la position pos *)
notes[pos]no ;
nn+1; (* incrémenter le nombre effectif de notes *)
SINON
ECRIRE (Tableau plein) ;
FINSI
FIN
18
Traitements simples
 Recherche d’éléments
Recherche complète
Principe
Parcourir tous les éléments du tableau en les soumettant au
critère de recherche.
Exemple
Ecrire un algorithme qui détermine le nombre d’apparitions
d’une note dans les notes déjà saisies d’un étudiant.
19
Traitements simples
Recherche complète
ALGORITHME
Principe recherche_totale
Parcourir
TYPE NOTE tous= les éléments
TABLEAU [NBMAX] duDEtableau en les de
REEL ; (* définition soumettant
type tableau *)au
VAR notes : NOTE; (* tableau des notes *)
critère de recherche.
n : ENTIER ; (* nombre effectif de notes de l’étudiant *)
Exemplei : ENTIER ; (* compteur de notes *)
Ecrireno un : REEL ; (* note à rechercher *)
algorithme
occ :ENTIER quid’occurrences
; (* nombre détermine de le
no nombre
*) d’apparitions
d’une note dans les notes déjà saisies d’un étudiant.
DEBUT
(* Lecture de la note à rechercher *)
ECRIRE(Entrer la note à rechercher:) ;
LIRE(no) ;
occ0 ; (* initialiser occ à 0 *)
(* parcours des éléments du tableau *)
POUR i DE 1 A n FAIRE
SI (notes[i] = no) ALORS
occocc+1 ;
FINSI
FINPOUR
ECRIRE ( no, est apparu , occ, fois) ;
FIN 20
Traitements simples
Recherche partielle
Principe
Parcourir les éléments du tableau et s’arrêter dès qu’on a
trouvé l’élément ou si on a terminé le tableau.
Exemple
Ecrire un algorithme qui recherche la première occurrence d’une
note dans les notes déjà saisies d’un étudiant
21
Traitements simples
Recherche partielle
ALGORITHME recherche_partielle
Exemple
VAR notes : NOTE (* tableau des notes *)
no : REEL ; (* note à rechercher *) Ou
DEBUT (* parcours des éléments du tableau *)
(* Lecture de la note à rechercher *) i1 ;
ECRIRE (Entrer la note à rechercher:) ; TANT QUE (i ≤ n ET notes[i]  no) FAIRE
LIRE (no) ; ii+1 ;
(* parcours des éléments du tableau *) FINTQ
i1 ; SI (i< n) ALORS (* si trouvé…….*)
TANT QUE (i < n ET notes[i]  no) FAIRE --------
ii+1 ; SINON
FINTQ ---------
SI (notes[i] = no) ALORS FINSI
ECRIRE (La première occurrence de ,no, se trouve au rang , i) ;
SINON
ECRIRE (no, n’est pas dans le tableau) ;
FINSI
FIN
22
Traitements simples
Recherche du minimum
Principe
Supposer que le premier élément contient le minimum ;
Parcourir les autres éléments du tableau et comparer
chaque élément avec le minimum supposé : si l’élément
courant est inférieur au minimum supposé, il devient le
minimum.
On peut rechercher le minimum soit par sa valeur soit par
sa position.
Exemple
Ecrire un algorithme qui recherche la plus faible des notes
déjà saisies d’un étudiant. 23
Traitements simples
Exemple (* Recherche du minimum par sa valeur *)
ALGORITHME recherche_min
CONST NBMAX 12 : ENTIER; (* taille du tableau qui doit être fixe *)
TYPE NOTE = TABLEAU [NBMAX] DE REEL;(* définition de type
tableau *)
min : REEL ; (* le minimum des notes *)
DEBUT
(* initialiser le minimum au premier élément du tableau *)
min notes[1];
(* parcours des éléments du tableau à la recherche du minimum *)
SI (notes[i] < min) ALORS
minnotes[i] ;
FINSI
FINPOUR
ECRIRE (La faible note est , min) ;
FIN 24
Traitements simples
Exemple
(* Recherche du minimum par sa position *)
ALGORITHME recherche_min
n, i : ENTIER ;
posmin : ENTIER ; (* la position du minimum des notes *)
DEBUT
(* initialiser le minimum au premier élément du tableau *)
posmin 1;
(* parcours des éléments du tableau à la recherche du minimum *)
SI (notes[i] <notes[posmin]) ALORS
posmini;
FINSI
FINPOUR
ECRIRE (La faible note est , notes[posmin]) ;
FIN
25
Tableaux une dimension
Traitements simples
Recherche du maximum
Principe
Supposer que le premier élément contient le maximum ;
Parcourir les autres éléments du tableau et comparer
chaque élément avec le minimum supposé : si l’élément
courant est supérieur au maximum supposé, il devient le
maximum.
On peut rechercher le maximum soit par sa valeur soit par
sa position.
Exemple
Ecrire une fonction qui recherche la plus forte des notes déjà
saisies d’un étudiant. 26
Traitements simples
Exemple
(* Recherche du maximum par sa valeur *)
ALGORITHME recherche_max
CONST NBMAX12:ENTIER;
TYPE NOTE = TABLEAU [NBMAX] DE REEL;
VAR notes : NOTE;
i, n: ENTIER;
max: REEL;
DEBUT
(* initialiser le maximum au premier élément du tableau *)
maxnotes[1];
(* parcours des éléments du tableau à la recherche du maximum *)
SI (notes[i] > max) ALORS
maxnotes[i] ;
FINSI
FINPOUR
ECRIRE (La faible note est , max) ;
FIN
27
Traitements simples
Exemple
(* Recherche du maximum par sa position *)
ALGORITHME recherche_max
VAR notes : NOTE;
i, n: ENTIER;
posmax: ENTIER;
DEBUT
(* initialiser le maximum au premier élément du tableau *)
posmax1;
(* parcours des éléments du tableau à la recherche du maximum *)
SI (notes[i] > notes[posmax]) ALORS
posmaxi ;
FINSI
FINPOUR
ECRIRE (La faible note est , notes[posmax]) ;
FIN
28
Traitements simples
 Suppression d’éléments
Suppression d’un élément connu par sa position
Principe :
 Décaler vers la gauche tous les éléments, s’ils existent, situés à droite de l’élément
à supprimer ;
 Décrémenter éventuellement le nombre effectif d’éléments du tableau.
Exemple
ALGORITHME Suppression_position
pos : ENTIER ; (* position de l’élément à supprimer *)
DEBUT
(* Lecture de la position de l’élément à supprimer *)
REPETER
ECRIRE( Entrer la position de l’élément à supprimer: ) ;
LIRE(pos) ;
JUSQU'A (pos1 ET pos n)
(* Décalage vers la gauche des éléments du tableau *)
POUR i DE pos A n-1 FAIRE
notes[i] notes[i+1];
FINPOUR
nn-1; (* décrémenter le nombre effectif de notes de l’étudiant *)
FIN 29
Traitements simples
Suppression d’un élément connu par sa valeur
Principe
Le principe consiste à se ramener au cas précédent :
Rechercher la position de l’élément à supprimer à l’aide
de sa valeur ;
Si l’élément est retrouvé, décaler vers la gauche tous les
éléments, s’ils existent, situés à droite de l’élément à
supprimer ;
Décrémenter éventuellement le nombre effectif
d’éléments du tableau.
30
Traitements simples
Suppression d’un élément connu par sa valeur
Exemple
Ecrire un algorithme qui supprime une note des notes déjà
saisies d’un étudiant..
31
ALGORITHME Suppression_valeur
Traitements
CONST NBMAX simples
12 : ENTIER ; (* taille du tableau qui doit être fixe *)
 Suppression
TYPE NOTE = TABLEAU d’éléments[NBMAX] DE REEL ; (* définition de type tableau *)
Suppression d’un
n : ENTIER ; (*élément connu
nombre effectif par
de notes de sa valeur
l’étudiant *)
Exemple no : REEL ; (* note à supprimer *)
Ecrire
DEBUT
posun algorithme
: ENTIER qui
; (* position desupprime une
l’élément à supprimer note
*) des notes déjà
saisies(*d’unLectureétudiant..
de la note à supprimer *)
ECRIRE(Entrer la note à supprimer :) ;
LIRE(no) ;
(* recherche de la position de l’élément dans le tableau, s’il est dans le
tableau*)
pos1 ;
TANT QUE (pos < n ET notes[pos]  no) FAIRE
pospos+1 ;
FINTQ
SI ( notes[pos]=no) ALORS ( * alors l’élément est trouvé au rang pos *)
(* Décalage vers la gauche des éléments du tableau *)
POUR i DE pos A n-1 FAIRE
notes[i] notes[i+1];
FINPOUR
nn-1; (* décrémenter le nombre effectif de notes de l’étudiant *)
SINON
ECRIRE(no, n’est pas dans le tableau) ;
FINSI
FIN 32
Tableaux
Algorithmes de tri à une dimension
Les programmes de tri de tableaux sont couramment
utilisés dans la gestion des données.
Un tri est en informatique une opération consistant à
réorganiser une collection d'objets selon un ordre
déterminé;
Les objets à trier devront donc faire partie d'un ensemble
muni d'une relation d'ordre total.
Si les objets sont réorganisés par ordre croissant (c'est-à-
dire l’élément d’indice i est inférieur ou égal à l’élément
d’indice i+1, pour tout i) on parle de tri croissant ;
Si les objets sont réorganisés par ordre décroissant (c'est-
à-dire l’élément d’indice i est supérieur ou égal à l’élément
d’indice i+1, pour tout i) on parle de tri décroissant.
On admettra qu’un tableau vide ou à un élément est trié.
Dans la suite, on traitera des tris croissants
https://interstices.info/les-algorithmes-de-tri/ ou
http://lwh.free.fr/pages/algo/tri/tri.htm 33
Algorithmes de tri
 Tri par sélection
Tri par sélection du minimum
Principe
Chercher l’indice du plus petit élément du tableau T[1..n] et
permuter l’élément correspondant avec l’élément d’indice 1;
Chercher l’indice du plus petit élément du tableau T[2..n] et
permuter l’élément correspondant avec l’élément d’indice 2 ;
……..
Chercher l’indice du plus petit élément du tableau T[n-1..n] et
permuter l’élément correspondant avec l’élément d’indice n-1;
En résumé, on parcourt le tableau T (i variant de 1 à n-1) et à
chaque itération i
- on détermine l'indice posmin du plus petit élément de T sur
l'intervalle [i..n]
- on échange T[i ] et T[posmin]
34
Algorithmes de tri
Principe
35
Algorithmes de tri
Exemple
Ecrire un algorithme qui classe par ordre croissant les n notes déjà
saisies d’un étudiant.
FONCTION indiceDuMinimum (E T :NOTE, E borneInf, E borneSup :ENTIER) :ENTIER
(* Précondition: T défini
borneSup≥borneInf
T défini sur [borneInf..borneSup]
Postcondition: pour chaque i [borneInf..borneSup], T[indiceDuMinimum(T, borneInf, borneSup)]≤
T[i]*)
VAR i, posmin: ENTIER;
DEBUT
posmin borneInf;
POUR i DE borneinf+1 A borneSup FAIRE
SI (T[i]<T[posmin)ALORS
posmini;
FINSI
FINPOUR
RETOURNER posmin;
FIN
36
Algorithmes de tri
Exemple
PROCEDURE echanger(E/S T :NOTE, E borneInf, E borneSup :ENTIER)
T[borneSup] et T[borneInf] définis
Postcondition: T[borneInf]=ancienne valeur de T[borneSup] et T[borneSup]=ancienne valeur de
T[borneSup] *)
VAR tmp: REEL;
DEBUT
tmpT[borneInf];
T[borneInf]T[borneSup];
T[borneSup]tmp;
FIN
PROCEDURE triParMinimumSuccessif (E/S T :NOTE,E n :ENTIER)

VAR i, indmin:ENTIER;
DEBUT
POUR i DE 1 A n-1 FAIRE (* à chaque itération, *)
indmin indiceDuMinimum (T, i, n); (* rechercher l’indice du petit plus élément
de T[i..n]*)
SI(indmin≠i)ALORS
echanger(T, i, indmin); (* le permuter éventuellement avec T[i]*)
FINSI
FINPOUR 37
Tableaux une dimension
Algorithmes de tri
Tri par sélection du maximum
Principe
Chercher l’indice du plus grand élément du tableau T[1..n] et
permuter l’élément correspondant avec l’élément d’indice n;
Chercher l’indice du plus grand élément du tableau T[1..n-1] et
permuter l’élément correspondant avec l’élément d’indice n-1 ;
……..
Chercher l’indice du plus grand élément du tableau T[1..2]
et permuter l’élément correspondant avec l’élément d’indice 2;
En résumé, on parcourt le tableau T (i variant de n à 2) et à
chaque itération i
-on détermine l'indice posmax du plus grand élément de T sur
l'intervalle [1..i]
-on échange T[i] et T[posmax]
38
Algorithmes de tri
Exemple
FONCTION indiceDuMaximum (E T :NOTE, E borneInf, E borneSup :ENTIER) :ENTIER
borneSup≥borneInf
T défini sur [borneInf..borneSup]
Postcondition: pour chaque i [borneInf..borneSup], T[indiceDuMinimum(T, borneInf, borneSup)]≥
T[i]*)
VAR i, posmax: ENTIER;
DEBUT
posmax borneInf;
POUR i DE borneinf+1 A borneSup FAIRE
SI (T[i]>T[posmax)ALORS
posmaxi;
FINSI
FINPOUR
RETOURNER posmax;
FIN
39
Algorithmes de tri
Exemple
T[borneSup] et T[borneInf] définis
Postcondition: T[borneInf]=ancienne valeur de T[borneSup] et T[borneSup]=ancienne valeur de
T[borneSup] *)
VAR tmp: REEL;
DEBUT
tmpT[borneInf];
T[borneSup]tmp;
FIN
PROCEDURE triParMaximumSuccessif (E/S T :NOTE,E n :ENTIER)

VAR i, indmax:ENTIER;
DEBUT
POUR i DE n A 2 DECROISSANT FAIRE (* à chaque itération, *)
indmaxindiceDuMaximum (T, 1, i); (* rechercher l’indice du petit pus élément
de T[1..i]*)
SI(indmax≠i)ALORS
echanger(T, i, indmax); (* le permuter éventuellement avec T[i]*)
FINSI
FINPOUR 40
Algorithmes de tri
 Tri par insertion
Principe
Insérer à sa position l’élément d’indice 2 dans la tranche triée
T[1] du tableau ;
Insérer à sa position l’élément d’indice 3 dans la tranche triée
T[1], T[2] ;
Et ainsi jusqu’à l’étape n où il faut insérer à sa position l’élément
T[n] dans la tranche triée T[1], T[2], …, T[n-1] ;
En résumé, on parcourt le tableau T (i variant de 2 à n) et à

chaque itération i
-on détermine la position j de T[i] dans l'intervalle [1..i]
-on insère T[i] à la jeme place.
41
Algorithmes de tri
Principe
42
Algorithmes de tri
Principe
43
Algorithmes de tri
Exemple
PROCEDURE inserer(E/S T :NOTE, E borneInf, E borneSup :ENTIER)
borneSup>borneInf
T défini sur [borneInf..borneSup] et trié sur [borneInf..borneSup-
1]
Postcondition: T trié sur [borneInf..borneSup] *)
VAR j: ENTIER; (* position d’insertion de T[borneSup]*)
aux: REEL;
DEBUT aux T[borneSup];
aux T[borneSup]; jborneSup;
jborneSup-1; TANT QUE(j>borneInf ET aux<T[j-1]) FAIRE
TANT QUE(j≥borneInf ET aux<T[j]) FAIRE
ou T[j]T[j-1];
T[j+1] T[j]; jj-1;
jj-1; FINTQ
FINTQ
T[j+1]aux; T[j]aux;
FIN
44
Algorithmes de tri
Exemple
PROCEDURE triParInsertion (E/S T :NOTE, E n: ENTIER)
VAR i: ENTIER;
DEBUT
inserer(T,1, i);
FINPOUR
FIN
Exercice
Définir la fonction obtenirIndiceDInsertion(T:NOTE, borneSup:ENTIER, no:
REEL) permettant d’obtenir la position d’insertion de no dans T. Précdition: T
trié sur [1..borneSup-1]

Définir la procédure decaler (E/S T :NOTE,E borneInf, E borneSup :ENTIER)
permettant de décaler vers la droite les T[borneInf], …, T[borneSup-1]
Définir, en utilisant les sous-programmes ci-dessous, la procédure
45
Algorithmes de tri
 Tri à bulles
Par remontée des minima
Principe
Remonter en première position le plus petit des n éléments
T[1], …, T[n]. Pour cela, on compare T[n] et T[n-1] ; si T[n] est
inférieur à T[n-1], une permutation est effectuée.
Ensuite, sont comparés et éventuellement permutés T[n-1] et
T[n-2], T[n-2] et T[n-3], …, T[2] et T[1].
Remonter en deuxième position le plus petit des n-1 éléments
T[2], …, T[n]. Pour cela, sont comparés et éventuellement
permutés T[n-1] et T[n-2], T[n-2] et T[n-3], …, T[3] et T[2]. ;
et ainsi jusqu’à remonter en avant dernière position le plus petit
des 2 éléments T[n-1], T[n]. ;
En résumé, à chaque parcours i (de 1 à n-1), on remonte à la
ième position le plus petit des T[i], …, T[n].
46
Algorithmes de tri
 Tri à bulles
Par remontée des minima
Exemple: Tri des n notes déjà saisies d’un étudiant.
VAR tmp: REEL;
DEBUT
tmpT[borneInf];
T[borneSup]tmp;
FIN
PROCEDURE triABulleMin (E/S T :NOTE, E n: ENTIER)
VAR i, j: ENTIER;
DEBUT
POUR i DE 1 A n-1 FAIRE
POUR j DE n A i+1 DECROISSANT FAIRE
SI(T[j]<T[j-1])ALORS
echanger(T, j-1, j);
FINSI
FINPOUR
FINPOUR
FIN
47
Algorithmes de tri
 Tri à bulles
Par descente des maxima
Principe
Au lieu de remonter respectivement les minimums vers le début
du tableau, on peut faire descendre respectivement les
maximums vers la fin du tableau.
Les cases gris clair représentent les
éléments comparées, les flèches rouges les
échanges d'éléments, et les case gris
sombre les éléments placés définitivement.
i=5 i=4 i=3 i=2

48
Algorithmes de tri
 Tri à bulles
Par descente des maxima
VAR tmp: REEL;
DEBUT
tmpT[borneInf];
T[borneSup]tmp;
FIN
PROCEDURE triABulleMax (E/S T :NOTE, E n: ENTIER)
VAR i, j: ENTIER;
DEBUT
POUR i DE n A 2 DECROISSANT FAIRE
POUR j DE 1 A i-1 FAIRE
SI(T[j]>T[j+1])ALORS
echanger(T, j, j+1);
FINSI
FINPOUR
FINPOUR
FIN
49
Algorithmes de tri
 Tri à bulles
Par permutation
Principe
Parcourir les éléments du tableau de 1 à n-1; si l'élément i
est supérieur à l'élément i+1 , alors on les permute.
On s'arrête lorsqu’aucune permutation n'est réalisée après
un parcours complet du tableau
50
Algorithmes de tri
 Tri à bulles
Par permutation
Principe
51
Algorithmes de tri
 Tri à bulles
Par permutation
VAR tmp: REEL;
DEBUT
tmpT[borneInf];
T[borneSup]tmp;
FIN
PROCEDURE triABullePermut (E/S T :NOTE, E n: ENTIER)
VAR i: ENTIER;
estTrie : BOOLEEN;
DEBUT
REPETER
estTrie .VRAI.;
POUR i DE 1 A n-1 FAIRE
SI (T[i]>T[i+1])ALORS
echanger(T,i,i+1);
estTrie .FAUX.;
FINSI
FINPOUR
JUSQU'A (estTrie)
FIN
52
Algorithmes de tri
 Tri à bulles
Par permutation optimisé
Principe
Parcourir les éléments du tableau de 1 à n-1; si l'élément i
est supérieur à l'élément i+1 , alors on les permute.
On s'arrête lorsqu’aucune permutation n'est réalisée après
un parcours complet du tableau
53
Algorithmes de tri
 Tri à bulles
Par permutation optimisé
PROCEDURE tri_bulle (E/S T:TABLEAU[NBMAX]DE TE, E n: ENTIER)
VAR passage: ENTIER;
DEBUT
passage ← 0;
REPETER
permut ← .FAUX.;
POUR i DE 1 A n - 1 - passage FAIRE
SI(T[i] > T[i+1])ALORS
echanger(T,i,i+1);
permut ← .VRAI.
FINSI
FINPOUR
passage ← passage + 1;
TANT QUE (permut = .VRAI.)
FIN
54
Algorithmes de recherche
Le but des algorithmes de recherche est de trouver un
élément donné parmi une liste d’éléments fourni par un
tableau.
 Recherche séquentielle(ou linéaire) dans un tableau non trié
Problème
Déterminer la première position d’une valeur donnée dans
un tableau de n éléments.
Principe
Parcourir le tableau jusqu’à ce qu’on trouve l’élément
recherché ou qu’on ait atteint la fin du tableau.
55
Algorithmes
CONST NBMAX …:ENTIER;
TYPE TAB= TABLEAU [NBMAX] DE TE;(* type des éléments *)
FONCTION recherche_Seq_NT1(E T : TAB, E n :ENTIER, E val: TE):ENTIER
VAR i, pos: ENTIER;
DEBUT
pos-1;
i1;
TANT QUE (i ≤ n ET pos=-1) FAIRE
SI (T[i] = val) ALORS
pos ← i;
SINON
i ← i+1;
FINSI
FINTQ
RETOURNER pos;
FIN
56
Algorithmes
FONCTION recherche_Seq_NT2(E T: TAB, E n :ENTIER, E val: TE):BOOLEEN
VAR i: ENTIER;
DEBUT
i1;
TANT QUE (i ≤ n ET T[i] ≠ val) FAIRE
ii+1 ;
FINTQ
RETOURNER i ≤ n;
FIN
57
 Recherche séquentielle(ou linéaire) dans un tableau trié
Problème
un tableau de n éléments triés par ordre croissant.
Principe
Parcourir le tableau jusqu’à ce qu’on trouve l’élément
recherché ou un élément supérieur à l’élément recherché
ou encore qu’on ait atteint la fin du tableau.
58
Algorithmes
FONCTION recherche_Seq_T1(E T : TAB, E n :ENTIER, E val: TE):ENTIER
(*précondition: n0*)
VAR i, pos: ENTIER;
DEBUT
pos-1;
i1;
TANT QUE (i < n ET T[i]<val) FAIRE
i ← i+1;
FINTQ
SI (T[i] = val) ALORS
pos ← i;
FINSI
RETOURNER pos;
FIN
59
Algorithmes
FONCTION recherche_Seq_T2(E T: TAB, E n :ENTIER, E val: TE):BOOLEEN
(*précondition: n0*)
VAR i: ENTIER;
DEBUT
i1;
TANT QUE (i < n ET T[i] < val) FAIRE
ii+1 ;
FINTQ
RETOURNER T[i]=val;
FIN
60
 Recherche dichotomique dans un tableau trié
Problème
un tableau de n éléments triés par ordre croissant.
Principe
Comparer l’élément recherché et l’élément médian du tableau :
Si l’élément recherché est strictement inférieur à l’élément
médian, il est obligatoirement, s’il trouve dans le tableau, dans la
partie gauche du tableau ; réappliquer alors le principe sur cette
partie ;
 Si l’élément recherché est strictement supérieur à l’élément
médian, il est obligatoirement, s’il se trouve dans le tableau, dans
la partie droite du tableau ; réappliquer alors le principe sur cette
partie ;
Si l’élément recherché est égal à l’élément médian alors fin de la
recherche ;
Arrêter la rechercher si l’élément est trouvé ou si la subdivision
du 61
 Recherche dichotomique dans un tableau trié
Algorithmes
FONCTION recherche_Dich(E T : TAB, E n :ENTIER, E val: TE):ENTIER
VAR inf, sup, mil, pos: ENTIER;
DEBUT
pos-1;
inf1;
supn;
TANT QUE (inf ≤ sup ET pos = -1) FAIRE
mil ← (inf+sup) DIV 2;
SI (T[mil] = val ) ALORS
pos ← mil;
SINON
SI (val<T[mil] ) ALORS
sup ← mil – 1;
SINON
inf ← mil + 1;
FINSI
FINSI
FINTQ
RETOURNER pos;
FIN 62
Fusion de tableaux triés
Problème
Il s’agit de remplir un tableau par les éléments de deux tableaux
ordonnés de sorte qu’à la fin, le tableau soit trié
Principe
Parcourir simultanément les tableaux triés : si l’élément courant du
premier tableau est inférieur à celui du deuxième tableau, il est
placé dans le troisième tableau sinon c’est l’élément courant du
deuxième tableau qui est mis dans le tableau ;
Continuer ainsi jusqu’à ce que l’un des deux tableaux soit fini ;
Recopier dans le tableau le reste des éléments du tableau restant
63
Fusion de tableaux triés
Algorithme
TAB1=TABLEAU [2*NBMAX] DE TE;
PROCEDURE Fusionner(E T1, E T2 : TAB, E n E m:ENTIER, ST:TAB1)
VAR i, j, k: ENTIER;
DEBUT (* recopie des éléments restants de T2 si
i1; T1 est fini le premier *)
j1; TANT QUE (j ≤≤ m) FAIRE
k1; T[k]T2[j] ;
TANT QUE (i≤ n ET j ≤m) FAIRE jj+1 ;
SI (T1[i] ≤ T2[j]) ALORS kk+1 ;
T[k] ← T1[i]; FINTQ
ii+1; FIN
SINON
T[k] ← T2[j];
jj+1;
FINSI
kk+1;
FINTQ
(* recopie des éléments restants de T1 si T2 est fini le premier *)
TANT QUE (i  n) FAIRE
T[k] T1[i] ;
i i+1 ;
k k+1 ;
FINTQ 64
Tableaux à deux dimensions
Généralités
 Définition
 Un tableau à deux dimensions est un tableau dont les
éléments sont des tableaux à une dimension.
 Les sous-tableaux sont appelés lignes et les positions
dans les sous-tableaux colonnes. Chaque élément d’un
tableau à deux dimensions est donc repéré par deux
indices: le numéro de sa ligne et le numéro de sa colonne.
 Un tableau à deux dimensions est caractérisé par le
nombre de ses lignes et le nombre de ses colonnes. Un
tableau à deux dimensions de L lignes et C colonnes
contient L*C composantes.
65
Généralités
 Définition
66
Généralités
 Déclaration
VAR
<nom_tableau> : TABLEAU[<taille1>] [<taille2>] DE <type_elts>;
Cette syntaxe déclare <nom_tableau> comme un tableau

de <taille1> tableaux de <taille2> éléments de type <
type_elt> chacun ; autrement dit <nom_tableau> est un
tableau de <taille1> lignes et <taille2> colonnes et
contient
<taille1>*<taille2> éléments de type <type_elt>.
Exemple: Déclarer un tableau devant contenir les notes
des 40 étudiants de IT1 dans les 12 matières de leur 67
Généralités
 Accès aux éléments
L’accès à un élément d’un tableau à deux dimensions se
fait selon la syntaxe suivante :
<nom_tableau>[<indice1>] [<indice2>]
Cette syntaxe désigne l’élément placé à la ligne <indice1>
et à la colonne <indice2>.
 Lecture et affichage de tableau
La lecture, de même que l’affichage, d’un tableau à deux
dimensions se fait par ligne et pour chaque ligne par
colonne.
Exemple
68
Applications (cf TD n°4 exo 22)
69
Types de données dérivés
Introduction
Chaînes de caractères
Intervalles
 Enumérations
Enregistrements
Pointeurs
Listes chaînées
Fichiers
70
Introduction
Un type dérivé est un type de données construit à partir de
types primitifs (caractère, entier, réel, booléen).
 Les types dérivés classiques sont :
Les types tableaux (déjà vus);
Les types chaînes de caractères;
Les types intervalles;
Les types énumérations;
Les types enregistrements;
Les types pointeurs;
Les types listes chaînées,
Les types fichiers.
71
Chaînes de caractères
Définition
Une chaîne de caractères est une suite de caractères.
Une chaîne de caractères peut être vide.
Une constante chaîne de caractères est une suite de
caractères placée entre double quote (″ ″).
Exemple: ″Bonjour !″ ; ″2245″ ; ″a″ ; ″″ (chaîne de caractères vide)
Déclaration
VAR
<nom_chaîne> : CHAINE[<taille>] ; (* chaînes de longueur maximale <taille> *)
ou
<nom_chaîne> : CHAINE ; (* chaînes de longueur variable *)
72
Déclaration
VAR
<nom_chaîne> : CHAINE[<taille>] ; (* chaînes de longueur maximale <taille> *)
ou
<nom_chaîne> : CHAINE ; (* chaînes de longueur variable *)
La première syntaxe déclare une chaîne de caractères de

longueur maximale <taille>
La deuxième syntaxe déclare une chaîne de caractères de
longueur maximale variable.
Exemple VAR
nom : CHAINE[25] ;
prenom : CHAINE ;
73
Affectation, lecture et affichage de chaîne de caractères
Une fois une chaîne de caractères déclarée, on peut
modifier sa valeur par affectation ou par lecture, afficher sa
valeur.
Exemple: Ecrire un algorithme qui lit et affiche le nom, le
prénom et la filière d’un étudiant.
ALGORITHME Etudiant
VAR Nom, prenom, filiere : CHAINE;
DEBUT
ECRIRE(″Entrer le nom de l’étudiant :″) ;
LIRE(nom) ;
ECRIRE(″Entrer le prénom de l’étudiant :″) ;
LIRE(prenom) ;
ECRIRE(″Entrer la filière de l’étudiant :″) ;
LIRE(filiere) ;
ECRIRE(″Nom : ″, nom, ″Prénom : ″, prenom, ″Filière :″, filiere) ;
FIN
74
Accès à un caractère d’une chaîne de caractères
L’accès à un caractère d’une chaîne de caractères se fait
de l’aide de l’opérateur d’indexation [ ] :
<nom_chaîne>[<indice>]
où <indice> peut être une constante, une variable ou une
expression entière représentant la position du caractère
dans la chaîne de caractères.
Exemple: Ecrire un algorithme qui lit le nom et le prénom
d’un étudiant et affiche ses initiales.
ALGORITHME initiale
VAR Nom, prenom : CHAINE ;
DEBUT
ECRIRE(″Entrer le nom de l’étudiant :″) ;
LIRE(nom) ;
ECRIRE(″Entrer le prénom de l’étudiant :″) ;
LIRE(prenom) ;
ECRIRE(″L’étudiant , nom, ″ ″, prenom, ″ a pour initiales:″, nom[1] , prenom[1]) ;
FIN 75
Opérations sur les chaînes de caractères
Opération Signification
SSCHAINE(<ch>, <pos>, <nb>) Extrait de la chaîne <ch> <nb> caractères à partir de la position <pos>
Renvoie une nouvelle chaîne constituée de la concaténation des

CONCAT(<ch1>, <ch2>)
chaînes <ch1> et <ch2>
Renvoie -1 si <ch1> est avant <ch2>, 0 si <ch1> et <ch2> sont
COMPARER(<ch1>, <ch2>)
identiques et 1 si <ch1> est après <ch2>
LONGUEUR(<ch>) Renvoie le nombre de caractères de la chaîne <ch>
Recherche dans <ch1> la sous chaîne <ch2> à partir de la position
RANG(<ch1>, <ch2>, <pos>) <pos> ; si <ch2> est trouvée, RANG donne la position du 1 er caractère
de <ch2>, sinon 0
Supprime de la chaîne <ch> <nb> caractères à partir de la position
SUPPRIMER(<ch>,<pos>,<nb>)
<pos>
CODE(<c>) Donne le code du caractère <c>
CAR(<n>) Donne le caractère dont le code est <n>
Convertit une variable ou une constante numérique en chaîne de
CVCHAINE(<nb>)
caractères
Convertit une variable ou une constante chaîne de caractères
CVNOMBRE(<ch>)
contenant une valeur numérique, en numérique
ENMAJUSCULE(<ch>) Convertit <ch> en majuscule
ENMINUSCULE(<ch>) Convertit <ch> en minuscule
76
Exercices
Ecrire un algorithme qui permet de conjuguer un verbe de 1er
groupe au présent de l’indicatif et au futur simple
Exemple : verbe chanter
Présent de l’indicatif Futur simple
Je chante Je chanterai
Tu chantes Tu chanteras
Il / elle chante Il / elle chantera
Nous chantons Nous chanterons
Vous chantez Vous chanterez
Ils/elles chantent Ils/elles chanteront
On vérifiera au moins que le verbe est terminer par er
77
Exercices
Ecrire un algorithme qui, après avoir enregistré les noms des m
employés de l’agence A d’une société et les noms des n
employés de l’agence B, classe les deux listes par ordre
alphabétique, les fusionne dans une liste commune AB.
On supposera qu’aucun nom ne dépasse 30 caractères
Exercices
Ecrire un algorithme d’un programme qui permet de saisir
une adresse E-mail sous la forme
Nom.prénom@serveur.extension d’une personne et
d’afficher son nom, son prénom, le serveur et l’extension.
Exemple : Adresse : Loya.youssouf@yahoo.fr
Le programme affiche :
Nom : LOYA Prénom : Youssouf Serveur : Yahoo Extension : fr
78
Intervalles
Définition
Un type intervalle est un sous-ensemble de valeurs
consécutives d'un type hôte.
Le type hôte doit être un type ordinal c’est-à-dire un type
admettant les opérateurs pred, succ et ord (le précédent,
le
successeur et le numéro d'ordre dans le codage): entier,
caractère, booléen, … 79
Intervalles
Définition d’un type intervalle
TYPE
<nom_type> = Bmin..Bmax;
Bmin et Bmax sont des constantes du même type, et sont

les bornes inférieure et supérieure de l'intervalle, Bmin et
Bmax inclus.
Bmin < Bmax
Exemple: Définir les types mois, semaine, alphabet
TYPE
Tmois= 1..12;
Tsemaine= 1..7;
Talphabet= ‘a'..‘z';
80
Intervalles
Opérations sur les types intervalle
Les primitives utilisables sur les objets de type intervalle
sont identiques à celles définies sur le type de base (i.e
type hôte).
81
Enumérations
Définition
Un type Enumération définit un ensemble ordonné fini de
valeurs désignées par des identificateurs.
Définition d’un type Enumération
TYPE
<nom_type> = {constant_1,.., constant_n};
Exemple: Définir les types jour contenant les jours de la
semaine, direction(Nord, Sud, Est, Ouest).
TYPE
JourSemaine= {Lundi, Mardi, Mercredi, Jeudi, Vendredi,
Samedi,
Dimanche};
Direction = {Nord, Sud, Est, Ouest};
82
Enumérations
Opérations applicables
Ord, Succ, Pred;
Opérateurs de comparaison.
Remarque
 on ne peut ni lire ni écrire une variable énumérée.
 Exemple:
TYPE TYPE
Sexe= {F, M}; Sexe= {F, M};
VAR sex:Sexe; VAR sex:Sexe;
s: CARACTERE; s: CARACTERE;
sexF; sexF;
LIRE(sex); (* incorrect *) ECRIRE(sex); (* incorrect *)
ECRIRE(Entrer le sexe (F/M):); ECRIRE(Le sexe : );
LIRE(s); SI(sex = F) ALORS
SI(s=‘F‘)ALORS ECRIRE(Féminin);
sex F; SINON
SINON ECRIRE(Masculin);
sexM; FINSI
FINSI
83
Enumérations
Exemples
CONST
JOUR_MAX 31:ENTIER ;
AN_MIN  2001: ENTIER;
AN_MAX  2100: ENTIER;
TYPE
Siecle = AN_MIN . . AN_MAX ;
jourSemaine = {lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche};
moisAnnee = {janvier, février, mars, avril, mai, juin, juillet, aout, septembre, octobre,
novembre, decembre};
VAR
mois: moisAnnee ;
jour: jourSemaine ;
nbJours : 1 .. JOUR_MAX ;
an: siecle ;
ouvrable : lundi .. Vendredi;
84
Enumérations
Exercices
Exercice1
On donne les valeurs suivantes:
ch = Algorithmiques.
PI =3.14 (constante)
Section = (Math, Sciences, Lettres, Economie, Informatique)
x =12,75
1°) Quel est le résultat retourné par chacune des instructions suivantes :
1. T[1]ARRONDI(x)<ORD(‘A’) ;
2. aLONGUEUR (ch) DIV ORD (Lettres) ;
3. b(TRONCATURE(x)- a MOD 4) ;
4. T[2]NON (ORD(Sciences) MOD 3 a) ;
5. ch1CVCHAINE(x) ;
6. T[3] RANG (ch1, 7,1)>b;
7. T[ORD(informatique)]a <a;
8. cRANG(ch, “SUCC('h’)”, 1) ;
2°) Déclarer en Algo : T, Section, ch, a et PI

85
Enumérations
Exercices
Exercice2
Soit le type Examen contenant les valeurs suivantes: Math, Anglais, Physique et informatique
1°) Qu’appelle-t-on le type Examen décrit ci-dessus?
2°) Proposer une déclaration du type Examen en respectant l'ordre des valeurs
proposé ci-dessus.
3°) Compléter le tableau ci-dessous par les types et les valeurs des variables A, B et C après
exécution des instructions suivantes:
APRED (Informatique);
BORD (Anglais) * 8 DIV4 ;
C(Math <Physique) ;
86
Enregistrements
Motivation
Supposons que l’on veut modéliser, c'est-à-dire
représenter, un produit dans un programme de gestion
d’une société de commercialisation de produits.
Or un produit est caractérisé par plusieurs informations :
son code, sa désignation, son prix unitaire, sa quantité en
stock, …
Représenter chaque information par une variable
indépendante serait fastidieuse et pourrait être source
d’incohérence ;
Placer ces informations dans un tableau est impossible car
ces informations a priori ne sont pas de même nature.
Des variables regroupant plusieurs informations de types
pouvant être différents constitueraient une bonne solution
à ce problème. 87
Enregistrements
Définition
On appelle enregistrement (ou agrégat ou article ou
structure) une variable formée d’un nombre fini de variables
pouvant être de types différents.
Chaque variable d’un enregistrement est appelée champ
ou membre.
Exemple: produit1
Remarque: Un enregistrement représente un objet matériel

ou immatériel du monde réel. Chaque champ de
l’enregistrement représente une information (c'est-à-dire
un élément de connaissance) sur l’objet.
88
Enregistrements
Enregistrement type et création d’enregistrement
Un enregistrement type est la description d’un ensemble
d’enregistrements (c’est-à-dire d’objets) de même nature.
C’est un moule à partir duquel les enregistrements sont
créés suivant la syntaxe :
<enreg 1>, …, <enreg n> : ENREGISTREMENT
<nom_champ
1> : <type_champ 1> ;
- - - --
------------ -
< nom_champ n> :
Exemple: Description des produits de la société suivie de
<type_champ n> ;
la création de quelques-uns. FINENR ;
89
Enregistrements
Enregistrement type et création d’enregistrement
Exemple: Description des produits de la société suivie de
la création de quelques-uns.
VAR Produit1, produit2 : ENREGISTREMENT
code : CHAINE [5];
designation : CHAINE[15] ;
prix_unit : REEL ;
stock : ENTIER ;
FINENR ;
Les enregistrements sont les occurrences de

l’enregistrement type.
90
Enregistrements
Type enregistrement
Pour faciliter l’utilisation des enregistrements, on définit à
partir de l’enregistrement type un type enregistrement :
TYPE
<nom_type_eng>= ENREGISTREMENT
<nom_champ
1> : <type_champ 1> ;
- - - -- - - - - - -
------------ --- -
< nom_champ n> :
Une fois le type enregistrement défini, il est possible de
<type_champ n> ;
déclarer les enregistrements partout à la suite. FINENR
91
Enregistrements
Type enregistrement
Exemple:
TYPE Produit=ENREGISTREMENT
code : CHAINE [5];
designation : CHAINE[15] ;
prix_unit : REEL ;
stock : ENTIER ;
FINENR
VAR Produit1, produit2 : Produit;
Remarque:
Les types des champs d’un enregistrement peuvent être
prédéfinis ou définis par l’utilisateur ;
Un champ a exactement les mêmes propriétés qu’une
variable de même type ;
Un champ d’un enregistrement peut être lui même un
enregistrement. 92
Enregistrements
Manipulation des enregistrements
La manipulation d'un enregistrement se fait au travers de
ses champs.
Comme pour les tableaux, il n'est pas possible de
manipuler un enregistrement globalement, sauf pour
affecter un enregistrement à un autre de même type ou
passer en paramètre un enregistrement.
 Accès aux champs
 Pour accéder aux champs d’un enregistrement, on utilise
l’opérateur de sélection de champ (.) suivant la syntaxe :
<nom_enr><nom_champ>
93
Enregistrements
 Accès aux champs
 Exemple:
LIRE(produit1.designation) ;
ECRIRE(produit1.designation) ;
produit1.prix_unit  750 ;
 Affectation
 Il est possible d’affecter un enregistrement dans un autre
à
condition qu’ils soient de même type.
 Tous les champs de l’enregistrement à affecter seront
recopies dans les champs de l’autre.
 Exemple:VAR p1, p2 : Produit ;
- -------- ------- ------
P2 p1 ;
94
Enregistrements
 Lecture d’enregistrement
 La lecture d’un enregistrement se fait champ par champ.
 Exemple:
VAR p: Produit ;
ECRIRE(″Entrer le code du produit : ″) ;
LIRE(p.code) ;
ECRIRE(″Entrer la désignation du produit : ″) ;
LIRE(p.designation) ;
ECRIRE(″Entrer le prix unitaire du produit : ″) ;
LIRE(p.prix_unit) ;
ECRIRE(″Entrer le stock du produit : ″) ;
LIRE(p.stock) ;
95
Enregistrements
 Ecriture d’enregistrement
 Comme pour la lecture, l’affichage d’un enregistrement se
fait champ par champ.
 Exemple:
VAR p: Produit ;
- -------- ------- ------
ECRIRE(″Affichage du produit ″) ;
ECRIRE(″Code : ″, p.code) ;
ECRIRE(″Désignation : ″, p.designation) ;
ECRIRE(″Prix unitaire: ″, p.prix_unit) ;
ECRIRE(″Stock : ″, p.stock) ;
96
Enregistrements
 Passage d'un enregistrement en paramètre d'un sous-
programme
 Il est possible de passer tout un enregistrement en
paramètre d'un sous-programme.
 Exemple:
PROCEDURE saisir( S p: Produit)
DEBUT
ECRIRE(″Entrer le code du produit : ″) ;
LIRE(p.code) ;
ECRIRE(″Entrer la désignation du produit : ″) ;
LIRE(p.designation) ;
ECRIRE(″Entrer le prix unitaire du produit : ″) ;
LIRE(p.prix_unit) ;
ECRIRE(″Entrer le stock du produit : ″) ;
LIRE(p.stock) ;
FIN 97
Enregistrements
Champs particuliers
 Enregistrements imbriqués
 Un champ d’un enregistrement peut être un
enregistrement; on dit alors que le deuxième
enregistrement est imbriqué dans le premier.
 Exemple:
98
Enregistrements
Champs particuliers
 Enregistrements imbriqués
 Exemple:
TYPE Fournisseur= ENREGISTREMENT
code : CHAINE [5];
nom: CHAINE [25];
adresse : CHAINE [25];
distance : REEL;
FINENR
Produit = ENREGISTREMENT
code : CHAINE [5];;
designation : CHAINE [15];
prix_unit : REEL ;
stock : ENTIER ;
fournisseur : Fournisseur ; (* fournisseur est un enregistrement*)
FINENR
VAR produit1: Produit ;
produit1.fournisseur.nom (* accède au nom du fournisseur du produit produit1*)
(* Lecture de la droite vers la gauche*)
99
Enregistrements
Champs particuliers
 Tableau comme champ d’un enregistrement
 Un tableau peut apparaître comme champ d’un
enregistrement.
 Exemple: Ecrire la déclaration d’un type TFiche permettant de
mémoriser les informations sur un étudiant :
• son nom ;
• son prénom ;
• sa date de Naissance, de type TDate (jour, mois, année)
• sa formation, représentée par deux lettres ;
• s’il est redoublant ou non ;
• son groupe de TD, représenté par un entier ;
• ses notes, représentées par un tableau note d’au plus MAXNOTES
réels;
• un entier nbnotes indiquant le nombre de notes valides dans le
tableau note.
100
Enregistrements
Champs particuliers
 Tableau comme champ d’un enregistrement
 Un tableau peut apparaître comme champ d’un
enregistrement.
CONST
Exemple:
MAXNOTES  20: ENTIER;
TYPE TMois = {Janvier, Fevrier, Mars, Avril, Mai, Juin, Juillet, Aout, Septembre, Octobre,
Novembre, Decembre };
TJour = 1..31;
TDate = ENREGISTREMENT
VAR etud: TFiche;
jj : TJour;
mm : TMois; etud.note[2] (* 2è note de l’étudiant etud *)
aa : ENTIER;
FINENR
TFiche = ENREGISTREMENT
nom: CHAINE;
prenom: CHAINE;
dateNaiss: TDate;
formation: CHAINE[2];
redoublant: BOOLEEN;
grpe_TD: ENTIER;
note: TABLEAU[MAXNOTES] DE REEL;
nbnotes: ENTIER;
FINENR 101
Enregistrements
Champs particuliers
 Enregistrement avec variantes
 Certains champs d'un enregistrement peuvent prendre
plusieurs formes différentes.
 Le choix entre les différentes alternatives est gouverné
par la valeur d’un discriminant, d’un sélecteur.
 Cette partie vient après la partie fixe constituée des
champs communs.
102
Enregistrements
Champs particuliers
Enregistrement avec variantes
Syntaxe
TYPE
<nom_type_eng>= ENREGISTREMENT
<nom_champ 1> : <type_champ 1> ;
- - - -- - - - - - - - - - - - - - - - - - - -
--
< nom_champ n> : <type_champ n> ;
<selecteur >: <type_scalaire>;
SUVANT(<selecteur>) FAIRE
<liste_const_1> :
(<variante_1>) ;
------------
-----
<liste_const_n> :
où(<variante_n>)
<variante_k> ;
est de la forme :
103
Enregistrements
Champs particuliers
Syntaxe
<nom_champ_k1> : <nom_type_k1> ;
--------------------
<nom_champ_km> : <nom_type_km> ;
Exemple: Soit une société qui a à gérer des informations sur son
personnel. Elle emploie au maximum 100 personnes. Pour chaque
employé, elle enregistre le nom, le prénom, l'adresse, le sexe et, s'il
s'agit d'un homme, la situation militaire (libéré, exempté, réformé ou
incorporable), s'il s'agit d'une femme, son nom de jeune fille. Une
adresse contient un numéro, un nom de rue, un code postal et un
nom de localité. Un nom ne dépasse jamais 30 caractères.
Proposer les structures de données nécessaires pour représenter ces
informations 104
Enregistrements
Champs particuliers
Exemple
CONST MAXE  100: ENTIER;

LGMAX  30: ENTIER;
TYPE NOM= CHAINE[LGMAX];
GENRE = { F, M};
SITMILITAIRE = {LIBERE, EXEMPTE, REFORME, INCORPORABLE};
ADRESSE = ENREGISTREMENT
numero: ENTIER;
nom_rue: NOM;
codePostal: ENTIER;
nom_localite: NOM;
FINENR
105
Enregistrements
Champs particuliers
Exemple
EMPLOYE = ENREGISTREMENT
nom_emp: NOM;
prenom_emp: NOM;
ad_em: ADRESSE;
sexe_emp: GENRE;
SUIVANT(sexe_emp) FAIRE
F: ( nom_jf: NOM;);
M: (sitmil: SITMILITAIRE;);
FINSVT
FINENR
106
Enregistrements
Tableaux d’enregistrements
Il arrive souvent que l’on veuille traiter non pas un seul
enregistrement mais plusieurs en même temps. On peut
alors déclarer un tableau d’enregistrements.
Exemple: Représenter l’ensemble des employés de
l’exemple précédent:
VAR employes: TABLEAU[MAXE] DE EMPLOYE;
107
Enregistrements
Exercice corrigé
Soit une société qui a à gérer des informations sur son personnel. Elle emploie au
maximum 100 personnes. Pour chaque employé, elle enregistre le nom, le prénom,
l'adresse, le sexe et, s'il s'agit d'un homme, la situation militaire (libéré, exempté,
réformé ou incorporable), s'il s'agit d'une femme, son nom de jeune fille. Une adresse
contient un numéro, un nom de rue, un code postal et un nom de localité. Un nom ne
dépasse jamais 30 caractères.
1.Proposer les structures de données nécessaires pour représenter ces informations.
2.Ecrire une procédure permettant de saisir respectivement une adresse et un
employé.
3.Ecrire une procédure permettant d’afficher respectivement une adresse et un
employé
4.Ecrire une fonction permettant d’obtenir respectivement le nombre d’employés de
sexe masculin et de sexe féminin. Ecrire et utiliser la fonction qui teste si un
employé est un homme.
5.Ecrire une fonction permettant d’obtenir le nombre d’employés d’un sexe donné.
6.Ecrire une procédure qui classe les employés par ordre alphabétique.
7.Proposer, à partir des sous-programmes ci-dessus, un algorithme qui gère les
informations du personnel de la société.
108
Enregistrements
Exercice corrigé
1.Proposer les structures de données nécessaires pour représenter ces informations.
TYPE NOM= CHAINE[LGMAX];
GENRE = { F, M};
SITMILITAIRE = {LIBERE, EXEMPTE, REFORME, INCORPORABLE};
ADRESSE = ENREGISTREMENT
numero: ENTIER;
nom_rue: NOM;
codePostal: ENTIER;
nom_localite: NOM;
FINENR
EMPLOYE = ENREGISTREMENT
nom_emp: NOM;
prenom_emp: NOM;
ad_emp: ADRESSE;
sexe_emp: GENRE;
SUIVANT(sexe_emp) FAIRE
F: ( nom_jf: NOM;);
M: (sitmil: SITMILITAIRE;);
FINSVT
FINENR
PERSONNEL= ENREGISTREMENT
eff: ENTIER; (* nombre d’employés *)
employes: TABLEAU[MAXE] DE EMPLOYE; (* liste des employés *)
FINENR
109
Enregistrements
Exercice corrigé
2.Ecrire deux procédures permettant de saisir respectivement une adresse et un
employé.
. (* Définition de la procédure de saisie d’une adresse *)
PROCEDURE saisir_Ad( S ad: ADRESSE)
DEBUT
ECRIRE(Entrer le numéro :);
LIRE(ad.numero);
ECRIRE(Entrer le nom de la rue :);
LIRE(ad.nom_rue);
ECRIRE(Entrer le code postal:);
LIRE(ad.codePostal);
ECRIRE(Entrer la localité:);
LIRE(ad.nom_localite);
FIN
110
Enregistrements
Exercice corrigé
2.Ecrire deux procédures permettant de saisir respectivement une adresse et un employé.
(* Définition de la procédure de saisie d’un employé *)
PROCEDURE saisir_Em( S em: EMPLOYE) SUIVANT(em.sexe_emp) FAIRE
VAR sexe, stmil: CARACTERE; F: ECRIRE(Entrer le nom de jeune fille:);
DEBUT LIRE(em.nom_jf);
ECRIRE(Entrer le nom de l’employé :); M: REPETER
LIRE(em.nom_emp); ECRIRE(Entrer la situation militaire: );
ECRIRE(Entrer le prénom de l’employé :); ECRIRE(Taper L pour Libéré );
LIRE(em.prenom_emp); ECRIRE(Taper E pour Exempté );
ECRIRE(Entrer l’adresse de l’employé:); ECRIRE(Taper R pour Réformé );
saisir_Ad(em.ad_emp); ECRIRE(Taper I pour Incorporable);
REPETER LIRE(stmil);
ECRIRE(Entrer le sexe de l’employé:); JUSQU’À(stmil='L‘ OU stmil=‘E' OU
LIRE(sexe); stmil=‘R' OU stmil=‘I' )
JUSQU’À(sexe='F' OU sexe= 'M') SUIVANT (stmil) FAIRE
SI (sexe=‘F‘) ALORS 'L': em.sitmilLIBERE;
em.sexe_empF; 'E‘: em.sitmilEXEMPTE;
SINON 'R': em.sitmilREFORME;
em.sexe_empM; 'I‘: em.sitmilINCORPORBLE;
FINSI FINSVT
FINSVT
FIN
111
Enregistrements
Exercice corrigé
3.Ecrire une procédure permettant d’afficher respectivement une adresse et un employé
. Définition de la procédure d’affichage d’une adresse *)
(*
PROCEDURE afficher_Ad( E ad: ADRESSE)
DEBUT
ECRIRE(Numéro : , ad.numero);
ECRIRE(Nom de la rue : , ad.nom_rue);
ECRIRE(Code postal: , ad.codePostal);
ECRIRE(Localité: , ad.nom_localite);
FIN
PROCEDURE afficher_Em( E em: EMPLOYE) (*Définition de la procédure d’affichage d’employé *)
DEBUT
ECRIRE(Nom de l’employé :, em.nom_emp);
ECRIRE(Prénom de l’employé : , em.prenom_emp);
ECRIRE(Adresse de l’employé:);
afficher_Ad(em.ad_emp);
ECRIRE(Sexe de l’employé: );
SI (em.sexe_emp=F) ALORS
ECRIRE(Féminin);
ECRIRE(Nom de jeune fille: , em.nom_jf);
SINON
ECRIRE(Masculin);
SUIVANT(em.sitmil) FAIRE
LIBERE: ECRIRE(Libéré);
EXEMPTE: ECRIRE(Exempté);
REFORME: ECRIRE(Réformé);
INCORPORABLE: ECRIRE(Incorporable);
FINSVT
FINSI
112
FIN
Enregistrements
Exercice corrigé
4.Ecrire deux fonctions permettant d’obtenir respectivement le nombre d’employés de sexe
masculin et de sexe féminin. Ecrire et utiliser la fonction qui teste si un employé est un homme.
. Définissons d’abord la fonction testant si un employé est un homme *)
(*
FONCTION estHomme( E em: EMPLOYE):BOOLEEN
DEBUT
RETOURNER (em.sexe_emp==M);
FIN
(* Définissons maintenant la fonction calculant le nombre d’hommes parmi les employés *)
FONCTION nbHomme( E pers: PERSONNEL):ENTIER
VAR nb, i: ENTIER;
DEBUT
nb0;
POUR i DE 1 A pers.eff FAIRE
SI(estHomme(pers.employes[i]) ALORS
nbnb+1;
FINSI
FINPOUR
RETOURNER nb;
FIN
(* Définissons enfin la fonction calculant le nombre de femmes parmi les employés *)
FONCTION nbFemme( E pers: PERSONNEL):ENTIER
DEBUT
RETOURNER (pers.eff-nbHommes(pers));
FIN 113
Enregistrements
Exercice corrigé
5.Ecrire une fonction permettant d’obtenir le nombre d’employés d’un sexe donné.
.
FONCTION nbSexe( E pers: PERSONNEL, E sexe: GENRE):ENTIER
VAR nb: ENTIER;
DEBUT
SI (sexe=M) ALORS
nbnbHomme(pers);
SINON
nbnbFemme(pers);
FINSI
RETOURNER nb;
FIN
114
Enregistrements
Exercice corrigé
6.Ecrire une procédure qui classe les employés par ordre alphabétique.
(* classer les employés par la méthode par sélection *)
.
PROCEDURE classer( E/S pers: PERSONNEL)
VAR i, j, imin: ENTIER;
em:EMPLOYE;
DEBUT
POUR i DE 1 A pers.eff-1 FAIRE
imini;
POUR j DE i+1 A pers.eff FAIRE
SI(COMPARER(pers.employes[j].nom_emp, pers.employes[imin].nom_emp)<0) ALORS
iminj;
FINSI
FINPOUR
SI(iimin)ALORS
empers.employes[i];
pers.employes[i]pers.employes[imin];
pers.employes[imin]em;
FINSI
FINPOUR
FIN
115
Enregistrements
Exercice corrigé
7.Proposer, à partir des sous-programmes ci-dessus, un algorithme qui gère les
informations du personnel de la société.
116
Pointeurs
Notion d’adresse
Un ordinateur comporte un processeur et de la mémoire
connectés par un bus
La mémoire est constituée de petites cases-mémoire

pouvant contenir un bit (0 ou 1) regroupées par lots de 8
appelés octets.
Chaque octet de la mémoire est identifié de manière
univoque par un numéro appelé adresse.
Toute variable manipulée dans un programme est stockée
en mémoire centrale et a donc une adresse.
117
Pointeurs
Notion de pointeur
Définition
Un pointeur est un objet qui peut contenir l'adresse
d’autres objets d’un type donné.
Si un pointeur P contient l'adresse d'un objet A, on dit que
P pointe sur A et on représente cela schématiquement
comme suit:
On dit aussi que A est l’objet pointé.

Déclaration
Un pointeur se déclare en précisant le type des objets
pointés:
VAR
<nom_ptr>: <type_pointé> ;
118
Pointeurs
Notion de pointeur
Déclaration
Exemple:
VAR
pt: REEL;
La déclaration d’un pointeur ne réserve pas l’espace
mémoire associé à l’objet pointé.
Les pointeurs sont généralement codés sur le même
nombre d’octets que les entiers, quelque soit l’objet pointé.
Type pointeur
Si T est un type, T est le type pointeur sur T. Donc on
peut définir un type pointeur par :
TYPE
<nom_type_ptr>= <type_pointé> ;
119
Pointeurs
Notion de pointeur
Pointeur nul
Le pointeur nul est une constante nommée NIL
(Not Identified Link) qui est compatible avec tout type
pointeur c’est à dire peut être affectée à tout pointeur.
Cette constante est utilisée pour indiquer qu’un pointeur ne
pointe nulle part c’est à dire qu’il ne contient pas d'adresse
utilisable.
Opérateur d’adresse
L’opérateur d’adresse @ appliqué à une variable permet
d’obtenir l’adresse de celle-ci. Sa syntaxe est :
@<nom_variable>
120
Pointeurs
Notion de pointeur
Opérateur d’adresse
L'adresse d'une variable d’un programme peut changer
d’une exécution à l’autre car le compilateur alloue les
blocs de mémoire qui sont libres, et ceux-ci ne sont pas les
mêmes à chaque exécution.
Exemple:
VAR i : ENTIER ;
pi : ENTIER; (* pointeur vers un entier *)
pi @i ; (* pi pointe sur i *)
Si un pointeur p pointe sur une variable x, alors p peut être

utilisé partout où on peut écrire x.
121
Pointeurs
Notion de pointeur
Opérateur de déréférencement
L’opération consistant à prendre la valeur de la case
mémoire pointée par un pointeur constitue un
déréférencement ou une indirection.
Cela est fait à travers l’opérateur  dont la syntaxe est :
<ptr>
Exemple:
VAR i, j : ENTIER ;
pi : ENTIER; (* pointeur vers un entier *)
pi  @i ; (* pi pointe sur i *)
pi 2 ; (* initialisation de la valeur pointée par pi à 2.
(i=2)*)
j pi + 1 ; (* utilisation de la valeur pointée par pi.
Si un pointeur p pointe sur une variable x, alors p peut
(j=3)*)
être utilisé partout où on peut écrire x. 122
Pointeurs
Pointeur vers un enregistrement
Un enregistrement possède une adresse correspondant à
l’adresse du premier champ de l’enregistrement.
On peut donc manipuler des pointeurs sur des
enregistrements.
Accès aux champs d’un enregistrement pointé
On peut accéder à un champ d’un enregistrement pointé à
l’aide de l’opérateur pointeur de champ, noté → dont la
syntaxe est : ptr_sur_enregistrement> → <champ_à_accéder>
Remarque:
On peut aussi accéder à un champ d’un enregistrement
pointé à l’aide des opérateurs de déréférencement et de
sélection.
ptr_sur_enregistrement> .<champ_à_accéder>
123
Pointeurs
Enregistrements auto référencés
Les enregistrements auto référencés ou récursifs font
référence à eux-mêmes, c'est-à-dire ce sont des
enregistrements dont des champs sont pointeurs sur eux-
mêmes.
Ils sont principalement utilisés pour implanter des
structures de données dont la définition formelle est un
énoncé récursif.
Exemple:
TYPE MONOME = ENREGISTREMENT
coef : REEL ; (* Coefficient du monôme *)
exp : ENTIER ;(* Degré du monôme *)
svt : MONOME; (*Pointeur sur le monôme suivant*)
FINENR
POLYNOME = MONOME; (*Un polynôme est un pointeur sur monôme *)
124
Pointeurs
Enregistrements auto référencés
Les enregistrements auto référencés permettent d’avoir
des structures de données semblables aux tableaux,
appelés listes chaînées, dans lesquelles l'accès à un
élément se fait par un pointeur au lieu d’indice.
Chaque élément étant repéré par ses voisins auxquels il
est relié.
 Liste simplement chaînée
 Liste doublement chaînée
125
Pointeurs
Gestion dynamique de la mémoire
Méthodes d’allocation de la mémoire
Dans un programme, les variables peuvent être allouées
(réservées) de deux manières différentes :
Statiquement : Avant l’exécution du programme, le
compilateur traite le code source et détermine l’ensemble
des variables et réserve un emplacement mémoire en
conséquence. Les variables ainsi allouées sont appelées
variables statiques.
La durée de vie de ces variables correspond à la durée de
vie soit du programme soit du sous-programme qui les a
déclarées. Ces variables sont stockées soit dans la zone
statique, soit sur la pile.
126
Pointeurs
Dynamiquement : pendant l’exécution du programme, il
est possible d’avoir besoin d’une variable pour une
utilisation relativement brève dans le temps. Une variable
est alors créée à la volée et elle sera détruite quand le
besoin ne s’en fera plus. Une variable ainsi créée est une
variable dynamique et est stockée dans la zone mémoire
appelée tas.
L'allocation statique de mémoire est considérablement
plus
efficace car effectuée avant le commencement du
programme.
127
Pointeurs
Quand le programme démarre, tout est prêt pour
fonctionner correctement et les variables sont très faciles à
atteindre et à manipuler. Par ailleurs le temps de réponse
est plus rapide.
L'allocation statique est toutefois moins flexible car elle
nécessite de connaître, avant l'exécution du programme, la
quantité et le type de mémoire désirés.
La taille mémoire nécessaire pour tout le temps
d'exécution du programme peut être très conséquente
suivant le nombre de variables. Par ailleurs, il n'est pas sûr
qu'une variable soit utile pendant toute la durée de vie du
programme. 128
Pointeurs
Les variables statiques sont des variables nommées que
l'on manipule directement, alors que les variables
dynamiques sont des variables non nommées (anonymes)
manipulées indirectement au travers de pointeurs.
L'allocation et la désallocation de variables statiques sont
gérées automatiquement par le compilateur ; l'allocation se
fait au démarrage du programme (ou à l’entrée d’un sous-
programme) et la désallocation à la fermeture de ce
dernier (à la sortie d’un sous-programme).
L'allocation et la désallocation de variables dynamiques, en
revanche, doivent être explicitement gérées par le
programmeur. 129
Pointeurs
Allocation dynamique de la mémoire
Syntaxe:
VAR ptr :typeponté ;
- ------------
ALLOUER (ptr) ;
Cette syntaxe réserve un emplacement mémoire de la
taille du type pointé typepointé et place dans ptr l’adresse
de cet emplacement en cas de succès ou NIL en cas
d’échec.
Libération dynamique de la mémoire
La libération de la mémoire allouée dynamiquement est à
la charge du programmeur.
Syntaxe: LIBERER(ptr);
130
Pointeurs
Tableaux dynamiques
Un tableau dynamique est un tableau dont la taille est
connue et l’emplacement des éléments réservé à
l’exécution.
Syntaxe:
VAR nom_tab : TABLEAU[] DE type_tab ;
- --------------------------
ALLOUER(nom_tab,nbr_elt) ;
Le tableau doit être libéré après utilisation :

LIBERER(nom_tab) ;
131
Listes chaînées
Motivation
Pour stocker une série de données de même nature,
nous disposons actuellement:
 Tableaux statiques
Allocation à la compilation d’un nombre « suffisamment »
grand (taille maximum) d’emplacements contigus.
Les tableaux statiques présentent certains inconvénients:
Le fait que la taille doit être connue à la compilation peut
entraîner un surdimensionnement (donc gaspillage de
mémoire), ou un sous dimensionnement (donc il sera
impossible d'agrandir ce tableau, en cas de besoin);
Le «suivant » doit toujours être stocké dans la cellule
suivante;
L’insertion et la suppression nécessitent un décalage
des éléments.
132
Listes chaînées
Motivation
 Tableaux dynamiques
Allocation à l’exécution d’un nombre d’emplacements
contigus. Grâce à la fonction REALLOUER, un tableau peut
être redimensionné pendant l’exécution.
Les tableaux dynamiques présentent néanmoins certains
inconvénients:
Le redimensionnement (allocation-recopie-désallocation)
consomme du temps et de l’espace

Le «suivant » doit toujours être stocké dans la cellule
suivante
L’insertion et la suppression nécessitent un décalage
des éléments
Les listes chaînées permettent d’éviter ces problèmes 133
Listes chaînées
Définition
Une liste chaînée est une structure de données dans
laquelle les éléments sont rangés linéairement.
Une liste chainée est simplement une suite finie d’éléments
de même type dans laquelle chaque élément contient :
des informations;
l'adresse de l'élément suivant(simple chaînage) ou les
adresses des éléments précédent et suivant(double
chaînage) ou une marque de fin s'il n'y a pas de suivant
ou de précédent.
134
Listes chaînées
Définition
L'adresse de l'objet suivant peut être :
une adresse mémoire récupérée avec un pointeur.
un indice de tableau récupéré avec un entier
une position dans un fichier. Elle correspond au numéro
d'ordre de l'objet dans le fichier multipliée par la taille en
octet du type de l'objet. Elle est récupérée avec un entier.
Que la liste chainée soit bâtie avec des pointeurs ou des
entiers, c'est toujours le terme de pointeur qui est utilisé.
Les éléments d’une liste chaînée sont appelés cellules,
nœuds, doublets ou maillons.
Les éléments d’une liste ne sont pas contigus en mémoire
contrairement à un tableau.
135
Listes chaînées
Avantages
Dynamiques: création et suppression des éléments à
l’exécution
Pas de limitation de la longueur maximum des listes
Facilité d’ajout, de suppression, de concaténation:
L’insertion et la suppression d’un élément à une place
quelconque, la concaténation de deux listes se font par
simple manipulation de pointeurs.
Opérations sur les listes chaînées
 Création d’une liste chaînée;
 Insertion dans une liste chaînée;
 Suppression dans une liste chaînée;
 Opérations diverses: Recherche dans une liste,
concaténation ou fusion de deux listes, inversion d’une
liste, tri d’une liste, ….
136
Listes chaînées
Listes simplement chaînées
 Définition
 Une liste simplement chaînée est une liste dont chaque
élément contient un pointeur sur l’élément suivant.
 Le premier élément d’une liste est sa tête et le dernier, sa
queue.
 Le pointeur du dernier élément est initialisé à NIL.
 Une liste est manipulée via un pointeur vers son premier
élément; si ce pointeur vaut NIL, la liste est vide.
 Pour accéder à un élément d'une liste simplement
chaînée,
on part de la tête et on passe d'un élément à l'autre à
l'aide du pointeur suivant associé à chaque élément: une
liste simplement chaînée ne peut être parcourue que dans137
Listes chaînées
 Définition
 Exemple
138
Listes chaînées
 Définition du type liste simplement chaînée
TYPE
(*Définition d’abord du type des maillons de la liste *)
Tmaillon= ENREGISTREMENT
champ1: type1;
champ2: type2;
----------------
champn: typen;
suivant:Tmaillon;
FINENR
(*Définition ensuite du type liste, pointeur sur Tmaillon *)
TListe =Tmaillon;
Exemple 1: Un polynôme peut être représenté par une liste chaînée dont
chaque maillon représente un monôme. Le polynôme suivant 2X 5- X + 3X2 + 17 peut
être représenté par la liste suivante :
139
Listes chaînées
Exemple 1:
Définir des structures permettant de représenter les monômes et les polynômes.
TYPE
Tmonome= ENREGISTREMENT
degre: ENTIER;
coeff: REEL;
suivant:Tmonome;
FINENR
(*Définition ensuite du type liste, pointeur sur Tmonome *)
Tpolynome =Tmonome;
Exemple 2: Un produit est caractérisé par une référence (entier), un prix unitaire
(réel), la quantité en stock, et une description (chaîne). On désire gérer les articles
d’un magasin à l’aide d’une liste chaînée.
140
Listes chaînées
.Exemple 2:
Définir le type enregistrement Tproduit qui permet de définir les nœuds de la

chaîne
TYPE
(*Définition d’abord du type des nœuds de la liste *)
Tproduit= ENREGISTREMENT
ref: ENTIER;
desig: CHAINE;
pu: REEL;
qte: ENTIER;
suivant:Tproduit;
FINENR
(*Définition ensuite du type liste, pointeur sur TProduit *)
TListeProduit=Tproduit;
141
Listes chaînées
. Exemple 3: Définir le type liste chaînée d’entiers
TYPE
(*Définition du type liste d’entiers *)
TListe=Tcellule
(*Définition du type des cellules de la liste *)
Tcellule= ENREGISTREMENT
elem: ENTIER;
suiv:TListe;
FINENR
142
Listes chaînées
 Création d’une liste vide
 Principe
(1) Déclarer une variable liste ou un pointeur sur maillon
VAR tete: TListe ; (* ou tete: Tmaillon *)
(2) Affecter la valeur NIL à cette variable

VAR tete: TListe ; (* ou tete: Tmaillon *)
teteNIL;
143
Listes chaînées
 Exemple 1: créer un polynôme vide
TYPE
Tmonome= ENREGISTREMENT
degre: ENTIER;
coeff: REEL;
suivant:Tmonome;
FINENR
(*Définition ensuite du type liste, pointeur sur Tmonome *)
Tpolynome =Tmonome;
(*Sous forme de fonction*) (*Sous forme de procédure*)

FONCTION CreerPolyVide() PROCEDURECreerPolyVide(S poly:Tpolynome)
DEBUT DEBUT
RETOURNER NIL; poly NIL;
FIN FIN
144
Listes chaînées
Exemple 2: Créer une liste de produits vide
TYPE
(*Définition d’abord du type des nœuds de la liste *)
Tproduit= ENREGISTREMENT
ref: ENTIER;
desig: CHAINE;
pu: REEL;
qte: ENTIER;
suivant:Tproduit;
FINENR
(*Définition ensuite du type liste, pointeur sur TProduit *)
TListeProduit=Tproduit;
TListeProduit CreerProdVide() void CreerProdVide(S

DEBUT prod :TListeProduit)
ou DEBUT
RETOURNER NIL;
FIN prod NIL;
FIN
145
Listes chaînées
 Création d’une liste non vide
Exemple 1 : Ecrire la fonction CreerListe permettant de créer une liste chaînée
de n éléments de type entier en insérant à la queue.
PROCEDURE creerListe(S L: TListe, E n:ENTIER)
VAR p, nouveau: TListe;
i: ENTIER; TYPE
DEBUT (*Définition du type liste d’entiers *)
ALLOUER(nouveau); TListe=Tcellule
ECRIRE("Entrer l’élément de tete: ");(*Définition du type des cellules de la liste *)
LIRE(nouveau->elem);
nouveau->suivNIL;
Lnouveau; elem: ENTIER;
pnouveau; suiv:TListe;
POUR i DE 2 A n FAIRE FINENR
ALLOUER(nouveau);
ECRIRE("Entrer l’élément : ", i);
p->suiv  nouveau;
p  nouveau;
FINPOUR
FIN
146
Listes chaînées
Exemple 2 : Ecrire la fonction CreerListe permettant de créer et de renvoyer une
liste chaînée de n éléments de type entier en insérant à la queue.
FONCTION creerListe(E n:ENTIER): TListe
VAR p, nouveau, L: TListe;
i: ENTIER; TYPE
pnouveau; suiv:TListe;
POUR i DE 2 A n FAIRE FINENR
ALLOUER(nouveau);
p  nouveau;
FINPOUR
RETOURNER L;
FIN 147
Listes chaînées
Exemple 3 : Ecrire la fonction CreerListe permettant de créer une liste chaînée
de n éléments de type entier en insérant à la tête.
PROCEDURE creerListe(S L: TListe, E n:ENTIER)
VAR nouveau: TListe;
i: ENTIER; TYPE
POUR i DE 2 A n FAIRE suiv:TListe;
ALLOUER(nouveau); FINENR
nouveau->suivL;
L nouveau;
FINPOUR
FIN
148
Listes chaînées
Exemple 4 : Ecrire la fonction CreerListe permettant de créer et de renvoyer une
liste chaînée de n éléments de type entier en insérant à la tête.
PROCEDURE creerListe(E n:ENTIER):TListe
VAR nouveau, L: TListe;
TYPE
i: ENTIER;
LIRE(nouveau->elem); Tcellule= ENREGISTREMENT
elem: ENTIER;
Lnouveau;
POUR i DE 2 A n FAIRE suiv:TListe;
ALLOUER(nouveau); FINENR
nouveau->suivL;
L nouveau;
FINPOUR
RETOURNER L;
FIN
149
Listes chaînées
 Affichage d’une liste
PROCEDURE afficherListe(E L:TListe)
VAR p: Tcellule; TYPE
pL;
TListe=Tcellule
(*Définition du type des cellules de la liste *)
TANT QUE (p≠NIL) FAIRE Tcellule= ENREGISTREMENT
ECRIRE(p->elem); elem: ENTIER;
suiv:TListe;
p  p->suiv;
FINENR
FINTQ
FIN
150
Listes chaînées
 Insertion en tête
 Principe
(1) Créer une cellule d’adresse P par appel à ALLOUER:
ALLOUER(P)
(2) Donner la valeur à l’information contenue dans cette

nouvelle cellule
P->Info  Val ;
(3) Assigner au champ "suivant" de la nouvelle cellule,

l’adresse de la cellule de tête
P->suivant  tete ;
(4) Définir la nouvelle cellule comme cellule de tête

tete  P;
151
Listes chaînées
 Principe
152
Listes chaînées
 Exemple : Ecrire la fonction InsererEnTete permettant d’insérer en tête un
nouvel élément dans une liste chaînée d’entiers
PROCEDURE InsererEnTete(E/S L:TListe, Eval:ENTIER)
VAR p: TCellule ;
DEBUT
ALLOUER(p);
p->elem  val;
p->suiv L;
L p;
FIN
153
Listes chaînées
 Insertion en queue
 Principe
(1)Créer une cellule d’adresse p par appel à ALLOUER:
ALLOUER(p)

nouvelle cellule
p->Info  Val ;
(3) Assigner au champ "suivant" de la nouvelle cellule,

l’adresse NIL
p->suivant  NIL ;
(4) Si la liste est vide (ie tete =NIL)

(4.1.) Définir la nouvelle cellule comme cellule de tête
tete  p;
154
Listes chaînées
 Principe
(4) Si la liste est non vide (ie tete ≠ NIL)
(4.1.) Définir un pointeur der initialisé à tete
VAR der: Tcellule;
der  tete;
(4.2.) Parcourir la liste jusqu’à la dernière cellule.

TANT QUE (der->Suivant ≠ NIL) FAIRE
derder->Suivant;
FINTQ
(4.3.) Assigner au champ "suivant" de la cellule
pointée par
der->Suivant p der l’adresse de la nouvelle cellule.
155
Listes chaînées
 Principe
156
Listes chaînées
Insertion dans une liste
 Exemple : Ecrire la fonction InsererEnQueue permettant d’insérer en queue
un nouvel élément dans une liste chaînée d’entiers.
PROCEDURE InsererEnQueue(E/S L:TListe, E val: ENTIER)
VAR P, nouveau : TCellule;
DEBUT
ALLOUER(nouveau);
nouveau->elemval;
nouveau->suiv  NIL;
SI(L= NIL) ALORS
L  nouveau;
SINON
p  L;
TANT QUE (p->suiv≠NIL)
p  p->suiv;
FINTQ
FINSI
FIN
157
Listes chaînées
 Insertion à une position donnée
 Principe
(1) Créer une cellule d’adresse p par appel à ALLOUER :
ALLOUER(p)
nouvelle cellule
p->Infoval ;
(3) si liste vide (ie tete =NIL) ou position d’insertion pos =1

(3.1.) Assigner au champ "suivant" de la nouvelle cellule,
l’adresse de la cellule de tête
p->suivant  tete ;
(3.2.) Définir la nouvelle cellule comme cellule de tête

tete p;
158
Listes chaînées
 Principe
(3) si liste non vide(ie tete≠NIL) et position d’insertion pos≠1
(3.1.) Définir un pointeur precedent initialisé à tete et i
initialisé à 1
VAR precedent : Tcellule;
i: ENTIER;
precedent  tete;
i 1;
(3.2.) Parcourir la liste jusqu’à la cellule de position pos-1.

TANT QUE (precedent->Suivant ≠ NIL ET i<pos-1) FAIRE
precedentprecedent->Suivant;
i i+1;
FINTQ
159
Listes chaînées
 Principe
(3) si liste non vide(ie tete≠NIL) et position d’insertion pos≠1
(3.3.) Assigner au champ "suivant" de la nouvelle cellule,
l’adresse de la cellule de rang pos
p->suivant precedent->suivant;
(3.4.) Assigner au champ "suivant" de la cellule de rang
pos-1, l’adresse de la nouvelle cellule
precedent->suivant  p;
160
Listes chaînées
 Principe
161
Listes chaînées
 Suppression en tête
 Principe
(1) si liste vide (ie tete = NIL)
Suppression impossible car liste vide
(1) si liste non vide (ie tete ≠ NIL)

(1.1) Définir un pointeur p initialisé à tete
VAR p: Tcellule;
p tete;
(1.2) Assigner à tete son suivant

tete  tete->suivant;
(1.3) Libérer l’espace occupé par la cellule qui était en tête

LIBERER(p);
162
Listes chaînées
 Suppression en queue
 Principe
(1) si liste vide (ie tete = NIL)
Suppression impossible car liste vide
(1) si liste non vide (ie tete ≠ NIL)

(1.1) Définir un pointeur p initialisé à tete
VAR p, q: Tcellule;
p tete;
(1.2) Parcourir la liste jusqu’à la dernière cellule

TANT QUE (p->suivant ≠ NIL) FAIRE
qp;
pp->suivant;
FINTQ
(1.3) Libérer l’espace occupé par la cellule en queue
q->suivant nil;
LIBERER(p);
163
Listes chaînées
 Suppression à une position donnée
 Principe
(1) si liste vide (ie tete = NIL) ou pos =1
Suppression en tête
(1) si liste non vide (ie tete ≠ NIL) et pos ≠ 1

(1.1) Définir un pointeur precedent initialisé à tete et i
initialisé à 1 VAR precedent : Tcellule;
i: ENTIER;
precedent  tete;
i 1;
(1.2) Parcourir la liste jusqu’à la cellule de position pos-1.
TANT QUE (precedent->Suivant ≠ NIL ET i<pos-1) FAIRE
precedentprecedent->Suivant;
i i+1;
FINTQ
164
Listes chaînées
 Principe
(1) si liste non vide (ie tete ≠ NIL) et pos ≠ 1
(1.3) Définir un pointeur p pointant sur la cellule de rang
pos
VAR p: Tcellule;
p  precedent->Suivant;
(1.4) Assigner au champ "suivant" de precedent le

suivant de p
precedent->Suivant  p->Suivant;
(1.5) Libérer l’espace occupé par la cellule de rang pos

LIBERER(p);
165
Listes chaînées
 Principe
166
Listes chaînées
 Autres opérations
 Recherche dans une liste (cf TD N°5 EXo6 4.)
 Concaténation de deux listes
 Fusion de deux listes
167
Listes chaînées
Exercices
Exercice 1(cf. exercice 6 du TD)
PROCEDURE CreatListe(S L: Liste, n:ENTIER)
VAR tete, p : Liste;
i : ENTIER;
DÉBUT
ALLOUER(tete);
ECRIRE(Entrer l’élément de tête : );
LIRE(tete.Elem);
tete.suiv NIL;
L tete;
ALLOUER(p);
Ecrire(Entrer un élément : );
LIRE(p.Elem);
p.suiv NIL;
L.suiv p;
L p;
FINPOUR
Ltete;
FIN
168
Listes chaînées
Exercices
PROCEDURE AffichListe(L: Liste, n:ENTIER)
VAR p : Liste;
DÉBUT
pL;
TANT QUE (pNIL) FAIRE
ECRIER(pElem);
ppsuiv;
FINTQ
FIN
PROCEDURE InsertTete(E/S L: Liste)

VAR p : Liste;
DÉBUT
ALLOUER(p);
Ecrire(Entrer un élément : );
LIRE(pElem);
psuiv L;
L p;
FIN
169
Listes chaînées
Exercices
FONCTION Recherche (L: Liste, x:ENTIER):BOOLEEN
VAR p : Liste;
trouve: BOOLEEN;
DÉBUT
pL;
trouve.FAUX.;
TANT QUE (pNIL ET trouve=.FAUX.) FAIRE
trouve(pElem=x);
ppsuiv;
FINTQ
RETOURNER trouve;
FIN
FONCTION Recherche (L: Liste, x:ENTIER):BOOLEEN
VAR p : Liste;
DÉBUT
pL;
TANT QUE (pNIL ET pElem≠x) FAIRE
ppsuiv;
FINTQ
RETOURNER (p≠NIL);
FIN
170
Listes chaînées
Exercices
PROCÉDURE Supprimer(E/S L :Liste, x : ENTIER)
VAR p ,q : Liste;
DÉBUT
SI(L≠NIL) ALORS
pL;
SI(L.Elem=x) ALORS
LL.suiv;
LIBÉRER(p);
SINON
qL.suiv;
TANT QUE (q≠NIL) ET(q.Elem≠x) FAIRE
p  q;
q  q.suiv;
FINTQ
SI(q≠NIL) ALORS
p.suiv q.suiv;
LIBÉRER(q);
SINON
ECRIRE(x, n’est pas dans la liste !);
FINSI
FINSI
SINON
ECRIRE(La liste est vide!);
FINSI
FIN 171
Listes chaînées
Exercices
PROCÉDURE Trier(E/S L :Liste)
VAR p ,q, min : Liste;
tmp: ENTIER;
DÉBUT
pL;
TANT QUE (p.suiv≠NIL) FAIRE
minp;
qp.suiv;
TANT QUE(qNIL) FAIRE
SI(q.Elem < min.Elem) ALORS
minq;
FINSI
qq.suiv;
FINTQ
tmpp.Elem;
p.Elemmin.Elem;
min.Elemtmp;
pp.suiv;
FINTQ
FIN
172
Listes chaînées
Exercices
Exercice 2
Un produit est caractérisé par une référence (entier), un
prix unitaire (réel), la quantité en stock, et une description
(chaîne). On désire gérer les articles d’un magasin à l’aide
d’une liste chainée.
173
Listes chaînées
Exercices
Exercice 2
 Définir la structure produit qui permet de définir les nœuds de la chaîne
 Ecrire les sous-programmes qui permettent les fonctionnalités suivantes :
1. Créer une liste vide
2. Afficher les produits contenus dans la liste
3. Ajouter un produit à la liste, si le produit existe déjà incrémenter sa quantité en
stock
4. Calculer le nombre de produit en stock (taille de la liste)
5. Supprimer un produit dont la référence est passé en paramètre, si le produit ne
figure pas dans la liste, afficher le message suivant : « produit introuvable »
6. Augmenter de 10% les prix des produits dont la quantité en stock est inférieure à
10 et afficher la liste de ces produits
7. Calculer le montant total de l’ensemble des produits du stock
8. Trier la liste des produits selon leurs références.
Exercice 3(cf. Exercice 7 du TD)
174
Listes chaînées
Exercices
1. Donner un algorithme Test(x:REEL, L :Liste) qui renvoie vrai s’il existe une cellule
dans L contenant la valeur x, et faux sinon
TYPE Cellule = ENREGISTREMENT
val: REEL;
suiv: Cellule;
FINENR
Liste = Cellule;
FONCTION Test(x :REEL, L:Liste): BOOLEEN
VAR p: Cellule;
DEBUT
pL;
TANT QUE (p NIL ET p.val < x) FAIRE
p p.suiv;
FINTQ
SI(p = NIL) ALORS
RETOURNER .FAUX.;
FINSI
RETOURNER (p.val = x);
FIN
175
Listes chaînées
Exercices
2. Donner un algorithme Ajouter(x:REEL, E/S L : Liste) qui ajoute une cellule (au
bon endroit pour que la liste reste triée) dans L, et qui renvoie la nouvelle liste (c-
à-d. l'adresse de la première cellule de la liste)
FONCTION Ajouter( x:REEL, E/SL:Liste): Liste
VAR p, q, c: Cellule;
DEBUT
pL;
TANT QUE (p NIL ET p.val < x) FAIRE
qp;
p p.suiv;
FINTQ
ALLOUER(c) ;
c.valx;
c.suivp;
SI(p=L) ALORS
Lc;
SINON
q.suivc;
FINSI
RETOURNER L;
FIN
176
Listes chaînées
Exercices
3. Etant donné un tableau de réels T contenant n valeurs, donner un algorithme qui
construit une liste chaînée triée avec toutes les valeurs de T.
TYPE Tab =TABLEAU[1..NBMAX] DE REEL;
PROCEDURE CreerListe(E/S L: Liste, T: Tab, n:ENTIER)
VAR p, q: Cellule;
i: ENTIER;
DEBUT
LNIL;
Ajouter(T[i], L);
FINPOUR
FIN
177
Fichiers
Généralités
Motivation
Les données d’un programme stockées en mémoire
centrale sont perdues dès la sortie du programme.
Cette volatilité de la mémoire constitue un handicap dans
certaines applications. Par exemple, si toutes les données
d’un programme qui gère les clients d’une banque sont en
mémoire uniquement, on serait amené à ressaisir à
chaque exécution du programme les informations sur les
clients ; ce qui n’est pas intéressant.
Les fichiers permettent de lever cet handicap en stockant
de manière permanente des informations entre deux
exécutions d’un programme.
178
Fichiers
Généralités
Motivation
En plus de ne pas être volatiles, les fichiers ont l’avantage
d’être dynamiques c'est-à-dire leurs tailles peuvent
augmenter au cours de leurs utilisations tant qu’il reste de
la place sur le support.
Leur principal inconvénient est le temps d’accès à une
donnée (de l’ordre de 106 plus lent que la mémoire).
Définition
Un fichier est un ensemble organisé d'informations (articles
ou enregistrements) de même nature stocké de façon
durable sur un support physique (mémoire de masse).
Au contenu du fichier est associé un nom ainsi qu’un
pointeur ou tête de lecture/écriture. 179
Fichiers
Généralités
Types de fichiers
On distingue deux types de fichiers suivant la façon dont
sont stockées les informations.
Fichiers binaires
Un fichier binaire contient des données enregistrées sous
une forme qui est la copie exacte de leur codage en
mémoire.
Les fichiers binaires ont les propriétés suivantes :
Ils sont peu encombrants. Par exemple si un entier
occupe 4 octets en mémoire, une variable entière
occupera aussi 4 octets dans un fichier binaire quelle que
soit sa valeur, d’où un gain de place;
180
Fichiers
Généralités
Fichiers binaires
Les fichiers binaires ont les propriétés suivantes :
Les opérations de lecture et d’écriture sont rapides car
elles ne réalisent aucune conversion.
Les fichiers binaires sont inexploitables par des
programmes externes qui ignorent la structure réelle du
fichier.
Fichiers texte
Dans un fichier texte, les données sont stockées sous
forme de caractères codés généralement suivant le code
ASCII (American Standard Code Information Interchange).
181
Fichiers
Généralités
Fichiers texte
Par exemple un float binaire (i .e. en mémoire) sera
transformé en décimal puis le caractère correspondant à
chaque chiffre sera écrit.
Les fichiers texte présentent les caractéristiques suivantes:
Alors que les fichiers binaires sont de simples suites
d’octets, les fichiers texte sont constitués de lignes,
chaque ligne est faite d’un nombre variable de caractères
qui se terminent par les caractères de contrôle de fin de
ligne.
182
Fichiers
Généralités
Fichiers texte
Les fichiers texte présentent les caractéristiques suivantes:
Les fichiers texte sont exploitables par des programmes
différents de celui qui les a produits.
Les opérations d’entrée/sortie nécessitent des
conversions pour transformer une suite de caractères en
une représentation compatible avec le type de variable à
affecter et inversement. Cette conversion demande un
traitement supplémentaire, de sorte que les opérations
d’entrée/sortie sont plus lentes sur les fichiers texte.
183
Fichiers
Généralités
Modes ou type d’accès
Le mode d’accès définit la manière dont l’ordinateur va
chercher les informations contenues dans un fichier.
On distingue deux modes d’accès.
Accès séquentiel
L’accès séquentiel consiste à traiter les informations
séquentiellement c’est- à-dire dans l’ordre où elles
apparaissent (ou apparaîtront) dans le fichier
On ne peut accéder à une information qu’en ayant au
préalable examiné celle qui précède.
Ce mode est possible aussi bien dans les fichiers texte que
dans les fichiers binaires ; dans le cas des fichiers texte,
cela signifie qu’on lit le fichier ligne par ligne. 184
Fichiers
Généralités
Accès direct(ou aléatoire)
L’accès direct consiste à se placer directement sur
l’information souhaitée sans avoir à parcourir celles qui la
précédent.
L’accès direct est généralement pour les fichiers binaires.
Remarque
Tout fichier peut être utilisé avec l'un ou l'autre des modes
d'accès.
Le choix du mode n'est pas un choix qui concerne le
fichier lui-même, mais uniquement la manière dont il va
être traité par la machine.
185
Fichiers
Généralités
Remarque
C'est donc dans le programme, et seulement dans le
programme, que l'on choisissons le mode d'accès
souhaité.
Organisation des fichiers
En général un fichier est constitué de groupements
informationnels élémentaires appelés enregistrements ou
articles.
Chaque enregistrement est constitué d’occurrences d’un
ensemble de propriétés appelées champs ou rubriques.
Cet ensemble de propriétés est appelé enregistrement
type du fichier. 186
Fichiers
Généralités
Considérons par exemple le fichier des produits d’un
magasin. Si un produit est caractérisé par sa référence, sa
désignation, sa couleur et sa quantité en stock, alors

l’enregistrement type du fichier sera composé des champs
référence (entier), désignation (chaîne), couleur (chaîne) et
quantité (entier).
101.compas.bleu.12 102.crayon.vert.18 103.stylo.bleu.17 104.papier.rouge.14
Enregistrement
187
Fichiers
Généralités
Parmi les champs d’un fichier, il y a la clé d’identification
qui permet de distinguer un article des autres. Dans
l’exemple ci-dessus référence est la clé d’identification.
Un fichier dispose aussi de clés d’accès c'est-à-dire de
rubriques ou groupes de rubriques à partir desquels on
pourra accéder à un enregistrement.
Une clé d’accès est appelée clé primaire s’il s’agit de la clé
d’identification, clé secondaire sinon.
L’organisation d’un fichier est l’ensemble des liaisons entre
les enregistrements stockés en mémoire secondaire.
Il existe plusieurs organisations de fichier ; toutes les
organisations permettent l’accès séquentiel. 188
Fichiers
Généralités
Organisation séquentielle
C'est une organisation simple qui consiste à ranger sur le
support de sauvegarde les enregistrements les uns
derrière les autres dans l'ordre de leur saisie.
En principe, seul l’accès séquentiel est possible; la fin du
fichier est repérée par un marqueur de fin du fichier.
L'adjonction d'enregistrement se fera toujours par la fin; il
faut que la tête de lecture/écriture se place en face du
marqueur de fin de fichier.
189
Fichiers
Généralités
Organisation séquentielle indexée
A chaque fichier physique est associé une ou plusieurs
tables appelées index stockées sur mémoire secondaire.
Un index est une table qui associe à la valeur d’une clé
d’accès l’adresse d’un enregistrement du fichier ayant
cette valeur de clé.
Il peut avoir plusieurs index pour un fichier.
Un index est appelé primaire s’il est construit à partir de la
clé primaire et secondaire s’il concerne une clé
secondaire.
190
Fichiers
Généralités
Exemple: Organisation du fichier des livres
191
Fichiers
Généralités
Exemple: index du fichier des produits
Index sur référence : index primaire Index sur couleur: index secondaire
Référence Adresse Couleur Adresse
Bleu 3
101 1
Bleu 5
102 2
Vert 2
103 3
Rouge 1
104 4
Rouge 4
105 5
Un index est unique, si à chaque valeur de la clé d’accès

correspond un seul enregistrement.
Un index peut être trié sur la clé d’accès ou non.
192
Fichiers
Généralités
Cette organisation permet les deux modes d’accès, l’accès
direct s’effectue par consultation de l’index.
Cette organisation est efficace dans la recherche d’un
ensemble d’enregistrements à partir d’une valeur d’une clé
d’accès.
L’ajout ou la suppression d’enregistrements nécessite
l’ajout ou la suppression de valeurs dans l’index.
La modification de valeur de la clé d’accès dans le fichier
nécessite une modification dans l’index.
193
Fichiers
Généralités
Organisation relative ou calculée
Chaque enregistrement est placé à une position précise
du fichier.
Cette position est:
Soit donnée comme numéro d’ordre de l’enregistrement
dans le fichier;
Soit calculée selon un algorithme de placement appliqué
à une clé.
On va pouvoir accéder aux enregistrements soit par leur
position, soit par un parcours séquentiel classique.
Il est possible d'ajouter un enregistrement à une position
quelconque. 194
Fichiers
Généralités
Remarque
Toutes les organisations ne sont pas possibles sur tous les
supports.
Par exemple, sur une bande magnétique, seule une
organisation séquentielle est possible.
Fichier logique
Un programme qui utilise un fichier physique déclare un
fichier logique qui correspond à la structure du fichier
physique.
195
Fichiers
Généralités
Fichier logique
À l'ouverture du fichier par le programme s'établit une
communication entre le fichier logique et le fichier physique
en mode lecture ou/et écriture.
196
Fichiers
Fichiers binaires à accès séquentiel
Définition
Un fichier à accès séquentiel ou fichier séquentiel est une
suite de valeurs disposées les unes à la suite des autres,
de façon que la lecture d'une valeur donnée ne puisse se
faire qu'après la lecture des valeurs précédentes.
Déclaration d’une variable fichier
Pour utiliser un fichier dans un programme, il faut d’abord
déclarer un fichier logique:
VAR nom_fich_log : FICHIER DE type_composants ;
où nom_fich_log est le nom du fichier logique
type_composants est le type des composants du fichier; il
peut être n’importe quel type: entier, caractère, réel,
enregistrement, …, sauf le type fichier 197
Fichiers
Déclaration d’une variable fichier
Exemple: Fichier des notes d’un étudiant
VAR notes: FICHIER DE REEL ;
Définition de type fichier
On définit un nouveau type fichier:
TYPE nom_type_fich= FICHIER DE type_composants ;
Exemple: Type fichier des notes des étudiants
TYPE Fnotes = FICHIER DE REEL ;
VAR notes: Fnotes;
198
Fichiers
Exercice
Un médecin enregistre sur ordinateur les fiches de ses
patients.
Une fiche a la structure suivante :
un nom (chaîne de 30 caractères maximum);
un numéro (entier);
un numéro de téléphone (10 caractères maximum);
un code d'assurance (entier non signé).
Définir le type fichier des patients du médecin
199
Fichiers
Exercice
CONST LGMAX10:ENTIER;
TYPE Patient = ENREGISTREMENT
nom : CHAINE[3*LGMAX];
numero : ENTIER;
tel : CHAINE[LGMAX];
code : ENTIER;
FINENR
FPatients = FICHIER DE Patient ;
200
Fichiers
Assignation d'un fichier logique
L’assignation d’un fichier logique consiste à associer c’est-
à-dire à relier son nom au nom du fichier physique:
ASSIGNER (nom_de_fichier_logique, nom_de_fichier_physique)
où nom_de_fichier_physique est soit une constante chaîne
soit une variable chaîne. Ce nom peut comprendre le

chemin (absolu ou relatif) du fichier.
TYPE Fnotes = FICHIER DE REEL ;
Exemple:
VAR notes: Fnotes;
DEBUT
ASSIGNER(notes, C:\etudiant\bulletin);
FIN
201
Fichiers
Assignation d'un fichier logique
L'opération d'assignation est obligatoire; une fois faite,
tous les accès au fichier physique se feront à l'aide du nom
du fichier logique.
Ouverture d'un fichier
Avant de pouvoir lire ou écrire dans un fichier, il faut
l’ouvrir.
OUVRIR(nom_de_fichier_logique, mode_Ouverture)
où mode_Ouverture est une chaîne de caractères qui

spécifie le type d’opérations que l’on veut effectuer ce
fichier.
mode_Ouverture ::= L| E| A|LE
202
Fichiers
Ouverture d'un fichier
Mode Définition
d’ouverture
ouverture du fichier en écriture seulement ; création du fichier s’il n’existe
pas;
E(Ecriture) si le fichier existe son ancien contenu est perdu.
ce qui va permettre de transférer les enregistrements du programme vers le
fichier par la procédure écrire()
ouverture du fichier en lecture seulement ; erreur si le fichier n’existe pas.
L(Lecture) ce qui va permettre de transférer les enregistrements du fichier vers le
programme par la procédure lire()
Ouverture du fichier en ajout, c'est-à-dire en écriture à la fin du fichier ;
A(Adjonction) création du fichier s’il n’existe pas; ce qui va permettre de transférer les
enregistrements du programme vers le fichier par la procédure écrire()
Ouverture du fichier en lecture/écriture
ce qui va permettre de transférer les enregistrements du fichier vers le
LE(Lecture/
programme par la procédure lire()
Ecriture)
ce qui va permettre de transférer les enregistrements du programme
vers le fichier par la procédure écrire()
203
Fichiers
Ecriture dans un fichier
L'écriture ou la modification d'une valeur ou d'un
enregistrement dans un fichier se fait grâce à l'instruction
ECRIRE suivi du nom logique du fichier puis de la variable
ou de la valeur à enregistrer dans le fichier :
ECRIRE(nom_de_fichier_logique, expression);
Cette syntaxe écrit à partir de la position courante de la tête

d'écriture sur le fichier nom_de_fichier_logique la valeur de
expression. La tête d'écriture est ensuite positionnée sur
l'élément suivant.
Exemple: Ecrire une procédure permettant de créer et
remplir le fichier des patients; pour arrêter le remplissage,
taper 0 comme numéro de patient. 204
Fichiers
Ecriture dans un fichier PROCEDURE remplissage(S fpa : FPatient)
Exemple: VAR pa: Patient;
CONST LGMAX10:ENTIER; DEBUT
TYPE OUVRIR(fpa, E); (*Ouvrir le fichier en écriture *)
Patient = ENREGISTREMENT
ECRIRE( Entrer le numéro du premier patient : );
numero : ENTIER; LIRE(pa.numero);
tel : CHAINE[LGMAX]; TANT QUE(pa.numero≠0) FAIRE
code : ENTIER;
ECRIRE(Entrer le nom du patient : );
FINENR
FPatient = FICHIER DE Patient ; LIRE(pa.nom);
ECRIRE(Entrer le téléphone du patient : );
LIRE(pa.tel);
ECRIRE(Entrer le code d’assurance : );
LIRE(pa.code);
ECRIRE(fpa,pa);(*écrit pa dans le fichier fpa*)
ECRIRE( Entrer le numéro du suivant: );
LIRE(pa.numero);
FINTQ
FIN 205
Fichiers
Lecture dans un fichier
La lecture d'une valeur ou d'un enregistrement du fichier se
fait par l'instruction LIRE suivi du nom logique du fichier
puis de la variable à lire.
LIRE(nom_de_fichier_logique, variable);
Cette syntaxe copie dans variable l’élément courant du

fichier nom_de_fichier_logique et déplace la tête de lecture
sur l'élément suivant.
Le type de la variable doit être le même que celui de
l'élément lu.
Exemple: (cf exemple suivant)
206
Fichiers
Fin de fichier
On peut à tout moment tester si on a atteint la fin d'un
fichier en lecture par la fonction booléenne FDF suivie du
nom logique du fichier qui retourne .VRAI. si la fin du
fichier est atteinte.
FDF(nom_de_fichier_logique)
Exemple: Ecrire une procédure permettant d’afficher la liste

des patients à partir leur fichier.
207
Fichiers
Fin de fichier PROCEDURE affichage(E fpa : FPatient)
Exemple: VAR pa: Patient;
CONST LGMAX10:ENTIER; DEBUT
TYPE OUVRIR(fpa, L); (*Ouvrir le fichier en lecture *)
Patient = ENREGISTREMENT
TANT QUE(NON(FDF(fpa))) FAIRE
numero : ENTIER; LIRE(fpa, pa); (*lire dans pa le patient pointé *)
tel : CHAINE[LGMAX]; ECRIRE(Numéro du patient : , pa.numero);
code : ENTIER;
ECRIRE(Nom du patient : , pa.nom);
FINENR
FPatient = FICHIER DE Patient ; ECRIRE(Téléphone du patient : , pa.tel);
ECRIRE(Code d’assurance : , pa.code);
FINTQ
FIN
208
Fichiers
Fermeture d'un fichier
Lorsque le traitement sur un fichier est terminé, il faut le
fermer à l’aide.
La fermeture d'un fichier spécifique se fait par l'instruction
FERMER suivi du nom logique du fichier.
FERMER(nom_de_fichier_logique)
La fermeture d’un fichier est obligatoire pour être sûr

d’avoir l’intégrité des données effectivement transférées
sur le fichier.
En effet, oublier de le faire sur un fichier qui a été ouvert en
écriture peut provoquer la perte de l’information qui y est
écrite.
Exemple: 209
Fichiers
Fermeture d'un fichier
Exemple:
PROCEDURE affichage(E fpa : FPatient) PROCEDURE remplissage(S fpa : FPatient)
VAR pa: Patient;
VAR pa: Patient; DEBUT
DEBUT OUVRIR(fpa, E);
OUVRIR(fpa, L); ECRIRE( Entrer le numéro du 1ier patient : );
TANT QUE(NON(FDF(fpa))) FAIRE LIRE(pa.numero);
TANT QUE(pa.numero≠0) FAIRE
LIRE(fpa, pa);
ECRIRE(Entrer le nom du patient : );
ECRIRE(Numéro patient : , pa.numero); LIRE(pa.nom);
ECRIRE(Nom du patient : , pa.nom); ECRIRE(Entrer le téléphone du patient : );
ECRIRE(Téléphone du patient : , pa.tel); LIRE(pa.tel);
ECRIRE(Entrer le code d’assurance : );
ECRIRE(Code d’assurance : , pa.code); LIRE(pa.code);
FINTQ ECRIRE(fpa,pa);
FERMER(fpa); ECRIRE( Entrer le numéro du suivant: );
FIN LIRE(pa.numero);
FINTQ
FERMER(fpa);
FIN
210
Fichiers
Exercice corrigé
Une entreprise souhaite enregistrer les informations (matricule, nom, prénom, grade,
salaire) sur ses employés.
1.Définir le type fichier des employés
2.Ecrire une procédure permettant de créer et remplir le fichier des employés
3.Ecrire une procédure permettant d’afficher la liste des employés à partir de leur
fichier.
4.Ecrire une procédure permettant d’afficher la liste des employés dont le salaire est
compris entre 500 000 et 700 000
5.Ecrire une procédure permettant de rechercher un employé dans le fichier à partir
de son matricule. Si l’employé est trouvé, l’algorithme doit afficher son nom, son
prénom et son grade, sinon il doit afficher ce message « Ce matricule ne figure pas
dans le fichier »
6.Ecrire une procédure qui copie les salaires des employés dans un tableau
T_Salaire.
7.Ecrire une procédure qui trie le tableau T_Salaire dans l’ordre décroissant.
8.Ecrire une procédure qui copie les salaires triés dans un nouveau fichier
Fi_Salaires
211
Fichiers
1.Définir le type fichier des employés
TYPE EMPLOYE = ENREGISTREMENT
matricule : ENTIER;
prenom : CHAINE[3*LGMAX];
grade: CHAINE[LGMAX];
salaire: REEL;
FINENR
FI_EMPLOYES = FICHIER DE EMPLOYE;
SALAIRES= TABLEAU[MAXE] DE REEL;
FI_SALAIRES= FICHIER DE REEL;
212
Fichiers
2.Ecrire une procédure permettant de créer et remplir le fichier des employés
PROCEDURE creation(S fe : FI_EMPLOYES)
VAR em : EMPLOYE;
DEBUT
OUVRIR(fe,E);
ECRIRE(Entrer le matricule de l’employé : );
LIRE(em.matricule);
TANT QUE(em.matricule≠0) FAIRE
ECRIRE(Entrer le nom de l’employé : );
LIRE(em.nom);
ECRIRE(Entrer le prénom de l’employé : );
LIRE(em.prenom);
ECRIRE(Entrer le grade de l’employé : );
LIRE(em.grade);
ECRIRE(Entrer le salaire de l’employé : );
LIRE(em.salaire);
ECRIRE(fe,em);
ECRIRE(Entrer le matricule de l’employé : );
LIRE(em.matricule);
FINTQ
FERMER(fe); 213
FIN
Fichiers
3.Ecrire une procédure permettant d’afficher la liste des employés à partir de leur
fichier.
PROCEDURE Consultation (E fe : FI_EMPLOYES)
VAR em : EMPLOYE;
DEBUT
OUVRIR(fe, L);
TANT QUE(NON(FDF(fe))) FAIRE
LIRE(fe, em);
ECRIRE(Matricule de l’employé : , em.matricule);
ECRIRE(Nom de l’employé : , em.nom);
ECRIRE(Prénom de l’employé : , em.prenom);
ECRIRE(Grade de l’employé : , em.grade);
ECRIRE(Salaire de l’employé : , em.salaire);
FINTQ
FERMER(fe);
FIN
214
Fichiers
4.Ecrire une procédure permettant d’afficher la liste des employés dont le salaire est
compris entre 500 000 et 700 000
PROCEDURE RechercheSal(E fe : FI_EMPLOYES)
VAR em : EMPLOYE;
DEBUT
LIRE(fe, em);
SI(em.salaire500 000 ET em.salaire700 000) ALORS
ECRIRE(Matricule de l’employé : , em.mtricule);
ECRIRE(Nom de l’employé : , em.nom);
ECRIRE(Prénom de l’employé : , em.prenom);
ECRIRE(Grade de l’employé : , em.grade);
ECRIRE(Salaire de l’employé : , em.salaire);
FINSI
FINTQ
FERMER(fe);
FIN
215
Fichiers
Exercice corrigé PROCEDURE RechercheMat(E fe : FI_EMPLOYES, E mat: ENTIER)
5.Ecrire une procédure VAR em : EMPLOYE;
permettant de rechercher DEBUT
un employé dans le OUVRIR(fe, L);
fichier à partir de son SI(NON(FDF(fe))) ALORS
matricule. Si l’employé LIRE(fe, em);
TANT QUE(NON(FDF(fe)) ET em.matriculemat) FAIRE
est trouvé, l’algorithme
LIRE(fe, em);
doit afficher son nom,
FINTQ
son prénom et son SI(em.matricule=mat) ALORS
grade, sinon il doit ECRIRE(Matricule de l’employé : , em.matricule);
afficher ce message « ECRIRE(Nom de l’employé : , em.nom);
Ce matricule ne figure ECRIRE(Prénom de l’employé : , em.prenom);
pas dans le fichier » ECRIRE(Grade de l’employé : , em.grade);
ECRIRE(Salaire de l’employé : , em.salaire)
SINON
ECRIRE(Ce matricule ne figure pas dans le fichier );
FINSI
SINON
ECRIRE(Ce fichier vide);
FINSI
FERMER(fe);
FIN
216
Fichiers
6.Ecrire une procédure qui copie les salaires des employés dans un tableau T_Salaire.
PROCEDURE CopieSal(E fe : FI_EMPLOYES, S T_Salaire: SALAIRES, S n: ENTIER)

VAR em : EMPLOYE;
DEBUT
n0;
LIRE(fe, em);
nn+1;
T_Salaire[n]em.salaire;
FINTQ
FERMER(fe);
FIN
217
Fichiers
7.Ecrire une procédure qui trie le tableau T_Salaire dans l’ordre décroissant.
(* tri par bulle (variante) des salaires *)

PROCEDURE TriSal(E/S T_Salaire: SALAIRES, E n: ENTIER)
VAR sal : REEL;
i: ENTIER;
echange: BOOLEEN;
DEBUT
REPETER
echange. FAUX. ;
POUR i DE 1 à n-1 FAIRE
SI(T_Salaire[i]< T_Salaire[i+1]) ALORS
salT_Salaire[i];
T_Salaire[i]T_Salaire[i+1];
T_Salaire[i+1]sal;
echange.VRAI. ;
FINSI
FINPOUR
JUSQU’À(echange = . FAUX.)
FIN
218
Fichiers
8.Ecrire une procédure qui copie les salaires triés dans un nouveau fichier Fi_Salaires
.
PROCEDURE RemplissageSal(S fs: FI_SALAIRES, E T_Salaire: SALAIRES, E n: ENTIER)
VAR i: ENTIER;
DEBUT
OUVRIR(fs, E);
POUR i DE 1 à n FAIRE
ECRIRE(fs, T_Salaire[i]);
FINPOUR
FIN
219
Fichiers
Fichiers binaires à accès direct
Définition
Un fichier est dit à accès direct si on peut accéder
directement à chacun de ses éléments.
Toutes les opérations vues ci-dessus sont applicables sur
les fichiers à accès direct.
Positionnement dans un fichier
DECALER(fichier, origine, decalage) ;
Cette syntaxe permet de se déplacer de decalage (peut
être<0)octets dans fichier, en partant de origine.
origine peut être:
0: Début du fichier;
1: Position courante ;
2: Fin du fichier.
220
Fichiers
Taille du fichier
TAILLE_FICH(fichier)
Cette syntaxe donne la taille du fichier fichier, en octets.
Position courante
POSITION_FICH(fichier)
Cette syntaxe retourne la position courante dans fichier, en
nombre d'octets à partir du début du fichier.
Exemple:
Remarque:
Le premier élément ou enregistrement d'un fichier occupe
la position 0 du fichier.
221
Fichiers
 Exercice corrigé: Fichier indexé
Soit un fichier d'articles de commerce ayant pour structure
TYPE TYPEART= ENREGISTREMENT
numero : ENTIER;
nom :CHAINE[20];
prixHT :REEL;
qte :ENTIER;
FINENR
FI_ARTICLE = FICHIER DE TYPEART ;
et déclaré comme suit:
VAR farticle : FI_ARTICLE;
1°) Créer ce fichier et le remplir avec des données.
Indication: - Un numéro article nul indique la fin de saisie
- Appeler le fichier articles.dat
222
Fichiers
1°) Créer ce fichier et le remplir avec des données.
ALGORITHME creation TYPE TYPEART= ENREGISTREMENT
VAR farticle : FI_ARTICLE; numero : ENTIER;
art: TYPEART; nom :CHAINE[20];
DEBUT prixHT :REEL;
ASSIGNER(farticle, C:\articles.dat ); qte :ENTIER;
OUVRIR(farticle, E); FINENR
ECRIRE(Entrer le numéro de l’article : ); FI_ARTICLE = FICHIER DE TYPEART;
LIRE(art.numero);
TANT QUE(art.numero≠0) FAIRE
ECRIRE(Entrer le nom de l’article : );
LIRE(art.nom);
ECRIRE(Entrer le prix de l’article : );
LIRE(art.prixHT);
ECRIRE(Entrer la quantité en stock de l’article : );
LIRE(art.qte);
ECRIRE(farticle, art);
ECRIRE(Entrer le numéro de l’article suivant : );
LIRE(art.numero);
FINTQ
FERMER(farticle); 223
FIN
Fichiers
2°) Les enregistrements sont rangés de façon consécutive et numérotés de 0 jusqu'à
n-1, pour un fichier de taille n.
Exemple: Fichier avec 5 enregistrements (présentés verticalement ici)
Ecrire un algorithme qui saisit un entier n et qui lit le nième enregistrement dans le
fichier pour afficher son nom. Pour n = 4 on doit afficher Livre.
.
224
Fichiers
2°) Ecrire un algorithme qui saisit un entier n et qui lit le nième enregistrement dans
le fichier pour afficher son nom.
.
ALGORITHME AccesDirect
n : ENTIER;
art: TYPEART;
DEBUT
ASSIGNER(farticle, C:\articles.dat );
OUVRIR(farticle, L);
ECRIRE(Entrer un rang: );
LIRE(n);
DECALER(farticle, 0,(n-1)*TAILLE(TYPEART)); (* se positionner sur le n ième article *)
LIRE(farticle,art); (* le récupérer *)
ECRIRE(L’article numéro : , n, est un(e) , art.nom);
FERMER(farticle);
FIN
225
Fichiers
3°) Dans la question précédente, on accède directement à un article étant donné son
rang dans le fichier. Or on voudrait surtout accéder à un article à partir d’une de ses
caractéristiques comme le numéro, le prix ou le nom, appelée alors clé d’accès.
Une idée de réaliser cet accès est de créer un index. C'est un deuxième fichier qui
contient pour chaque clé numéro d'article (par exemple), le rang physique de
l'enregistrement dans le fichier. C'est à dire au numéro d'article 11 on fait
correspondre le rang 3. Voir figure ci-dessous.
La recherche de l'article dont le numéro est num, par exemple, se fait alors en deux
étapes:
Etape 1: On parcourt d'abord le fichier index à la recherche de l'enregistrement de
clé num (recherche triée). On a alors la valeur de l'autre champ, qui est le rang
physique de l’article dans le fiche indexé article.
Etape 2: On accède ensuite au fichier indexé article directement à l'enregistrement à
partir du rang 226
Fichiers
3°) a) Ecrire un algorithme qui crée le fichier index sur le numéro de l’article. Pour
créer l’index, on parcourt séquentiellement le fichier article à indexer, et on
sauvegarde dans un tableau les couples <numéro article, i> i=0..n-1. On trie ce
tableau par ordre croissant de numéro article. On crée ensuite le fichier index à partir
de ce tableau trié.
ALGORITHME creationindex
numero : ENTIER;
nom :CHAINE[20];
prixHT :REEL;
qte :ENTIER;
FINENR
TYPEINDEX = ENREGISTREMENT
cle: ENTIER; (* stocke le numéro d’un article *)
rang: ENTIER; (* stocke son rang dans le fichier *)
FINENR
FI_INDEX = FICHIER DE TYPEINDEX;
findex: FI_INDEX;
tabindex: TABLEAU[100] DE TYPEINDEX;
n, i : ENTIER;
art: TYPEART;
ind: TYPEINDEX; 227
Fichiers
3°) a) Ecrire un algorithme qui crée le fichier index sur le numéro de l’article.
DEBUT
(* Parcours séquentiel du fichier des articles afin de remplir le tableau des couples <numéro, i> *)
i0;
TANT QUE(NON FDF(farticle)) FAIRE
LIRE(farticle, art);
tabindex[i+1].cle  art.numero;
tabindex[i+1].rang i;
ii+1;
FINTQ
FERMER(farticle);
(* tri du tableau tabindex *)
n  i;
REPETER
echange. FAUX. ;
POUR i DE 1 à n-1 FAIRE
SI(tabindex[i].cle>tabindex[i+1].cle) ALORS
ind tabindex[i];
tabindex[i]tabindex[i+1];
tabindex[i+1]ind;
echange.VRAI. ;
FINSI
FINPOUR 228
JUSQU’À(echange = . FAUX.)
Fichiers
3°) a) Ecrire un algorithme qui crée le fichier index sur le numéro de l’article.
(* Création du fichier index à partir du tableau trié tabindex *)
ASSIGNER(findex, C:\index.dat );
OUVRIR(findex, E);
ECRIRE(findex, tabindex[i]);
FINPOUR
FERMER(find);
FIN
3°) b) Ecrire un algorithme qui fait la recherche du nom d'un article étant donné son
numéro. Le programme doit utiliser l'index ainsi créé
229
Fichiers
3°) b)
ALGORITHME rechercheindex
numero : ENTIER;
nom :CHAINE[20];
prixHT :REEL;
qte :ENTIER;
FINENR
TYPEINDEX = ENREGISTREMENT
cle: ENTIER; (* stocke le numéro d’un article *)
rang: ENTIER; (* stocke son rang dans le fichier *)
FINENR
FI_INDEX = FICHIER DE TYPEINDEX;
findex: FI_INDEX;
num : ENTIER;
art: TYPEART;
ind: TYPEINDEX;
DEBUT
ECRIRE(Entrer le numéro de l’article recherché: );
LIRE(num);
230
Fichiers
3°) b)
(*Parcours séquentiel du fichier index pour chercher un couple dont le champ clé est égal à num *)
ASSIGNER(findex, C:\index.dat );
OUVRIR(findex, L);
SI(NON FDF(findex) ALORS
LIRE(findex, ind);
TANT QUE(NON FDF(findex) ET ind.cle< num) FAIRE
LIRE(findex, ind);
FINTQ
SI(ind.cle = num) ALORS
DECALER(farticle, 0, ind.rang*TAILLE(TYPEART));
LIRE(farticle,art);
ECRIRE(L’article numéro : , num, est un(e) , art.nom);
FERMER(farticle);
SINON
ECRIRE(Aucun article numéro , num,  ne figure dans le fichier );
FINSI
SINON
ECRIRE(Le fichier index est vide );
FINSI
FERMER(findex);
FIN
231
Fichiers
Fichiers texte
Déclaration
VAR nom_fich_log : FICHIER TEXTE;
Toutes les opérations vues ci-dessus sont applicables sur
les fichiers texte.
En plus il y a des opérations qui leur sont spécifiques.
Test de fin de ligne
FDL (nom logique)
Cette syntaxe retourne .VRAI. si l'on se trouve en fin de
ligne et .FAUX. dans le cas contraire.
Exemple:
232
Fichiers
Fichiers texte
Ecriture/Lecture caractère par caractère
ECRIRE_C( fichier, car);
Cette syntaxe écrit le caractère car dans fichier, puis
avance le pointeur du fichier.
LIRE_C( fichier, variable);
Cette syntaxe place dans variable, le prochain
caractère présent dans fichier et avance le pointeur de
fichier.
Ecriture/Lecture ligne par ligne
ECRIRE_LIG(fichier, valeur);
Cette syntaxe écrit dans fichier valeur puis le caractère de
fin de ligne
233
Fichiers
Fichiers texte
Ecriture/Lecture ligne par ligne
LIRE_LIG( fichier, variable);
Cette syntaxe lit dans variable le contenu d’une ligne de
fichier, puis pointe la prochaine ligne.
On souhaite stocker sur disque dur ou disquette les opérations concernant des
comptes bancaires. Chaque opération constitue une ligne de la forme :
Numéro_de_compte Date Montant Libellé
234
Fichiers
Fichiers texte
1. Ecrire un algorithme permettant de saisir un nombre indéterminé d’opérations et de les stocker
dans un fichier. On considère que l’utilisateur ne commet pas d’erreur de saisie
ALGORITHME Ecriture_operation
VAR fich : FICHIER TEXTE;
num : ENTIER;
date, libelle : CHAÎNE;
montant : RÉEL;
DEBUT
ASSIGNER(fich, C:\operations.txt);
OUVRIR(fich, E);
ECRIRE(Entrer le numéro du compte: );
LIRE(num);
TANT QUE(num>0) FAIRE
ECRIRE(Entrer la date de l’opération : );
LIRE(date);
ECRIRE(Entrer le montant de l’opération : );
LIRE(montant);
ECRIRE(Entrer le libellé (Dépôt, retrait, .., ) de l’opération : );
LIRE(libelle);
ECRIRE(fich, num, date, montant, libelle); (* enregistrement d’une ligne *)
ECRIRE(Entrer le numéro du compte suivant: );
LIRE(num);
FINTQ
FERMER(fich); 235
FIN
Fichiers
Fichiers texte
2. Ecrire un algorithme permettant de relire et d’afficher les données stockées dans le fichier précédent
ALGORITHME lecture_operation
VAR fich : FICHIER TEXTE;
num : ENTIER;
montant : RÉEL;
DEBUT
OUVRIR(fich,  L );
TANT QUE(NON FDF(fich)) FAIRE
LIRE(fich, num, date, montant, libelle);
ECRIRE(num,  , date,  , montant,  , libelle);
FINTQ
FERMER(fich);
FIN
236
Fichiers
Fichiers texte
3. Ecrire un algorithme permettant d’ajouter les données du fichier précédent aux données d’un
fichier préexistant, non vide, de même structure
ALGORITHME lecture_operation
VAR fich, fich_ancien : FICHIER TEXTE;
num : ENTIER;
montant : RÉEL;
DEBUT
OUVRIR(fich, L);
ASSIGNER(fich_ancien, C:\operations-ancien.txt);
OUVRIR(fich, A);
TANT QUE(NON FDF(fich)) FAIRE
LIRE(fich, num, date, montant, libelle);
ECRIRE(fich_ancien, num, date, montant, libelle);
FINTQ
FERMER(fich);
FERMER(fich_ancien);
FIN
237
Fichiers
Autres opérations sur les fichiers
Effacement d’un fichier
EFFACER (fichier);
Cette syntaxe efface fichier. Celui-ci peut être
indifféremment ouvert ou fermé avant effacement.
Renommage d’un fichier
RENOMMER (fichier, nouveau nom physique);
Cette syntaxe change le nom physique de fichier.
Cette opération nécessite que le fichier soit d’abord fermé.
Troncature d’un fichier
TRONQUER (fichier);
Tronque fichier à la position courante du pointeur de
Fichier: Tout ce qui se trouve au-delà du pointeur est alors
perdu. 238
Structures de données
linéaires
Structures de données
Les piles
Les files
Les listes
 Les dèques
239
L’essentiel des traitements informatiques consiste à
manipuler des données. Il est donc important
d’organiser et structurer les données d’un programme
d’une manière appropriée aux traitements envisagés.
Niveaux d’organisation des données
Les données manipulées dans les algorithmes et
programmes sont le plus souvent organisées selon deux
niveaux
240
niveaux
 Niveau individuel
 Au niveau individuel, les données sont généralement
organisées en entité (tableau, enregistrement, …) ;
 chaque entité comprend :
 Un ensemble d’informations organisées en champs
ou éléments,
 Eventuellement une clé associée aux informations
qui sert à les retrouver.
241
niveaux
 Niveau collectif
 L’organisation des données au niveau collectif définit les
relations entre ces données permettant de faciliter leur
manipulation.
242
Définition
Une structure de données est une organisation d’un
ensemble de données, conçue en fonction des
opérations qu’on prévoit de lui faire subir pendant sa vie.
C’est une composition de données unies par une même
sémantique.
On distingue deux types de structures de données selon
la manière dont elles sont décrites..
 Structure de données abstraite
 Lorsqu’on utilise une structure de données, l’important
est de connaître les opérations que l’on peut effectuer
sur les données; la façon dont les opérations sont
programmées n’a pas d’intérêt pour l’utilisateur. 243
Définition
 On distingue deux types de structures de données selon
la manière selon la manière dont elles sont décrites..
 Une structure de données abstraite ou type de données
abstrait (TDA) est la description, à travers des
opérations, de ce qu’on peut faire sur une collection de
données, cela indépendamment de toute
implémentation (représentation) en machine.
 La définition d’un TDA comprend :
244
Définition
La définition d’un TDA comprend :
Le concept, qui est l’ensemble de phrases en langage
naturel ayant pour but d’expliquer la réalité modélisée
en TDA ;
Les opérations ; chaque opération est décrite par :
 Sa signature ou prototype qui est l’énoncé des types
des objets qu’elle reçoit et qu’elle renvoie ;
 Ses propriétés ;
Une opération peut être de type création, consultation,
ou modification. 245
Définition
 Structure de données concrète
Une structure de données concrète est une implantation
d’une structure de données abstraite dans un langage
particulier.
L’implantation consiste à choisir des types de données
du langage pour représenter les ensembles du TDA et à
rédiger le corps des différentes opérations.
Une structure de données abstraite peut donner lieu à
plusieurs structures de données concrètes, avec des
performances différentes.
246
Structures de données linéaires
Les structures de données linéaires (SDL) organisent les
données sous de séquence non ordonnée d’éléments
accessibles de façon séquentielle.
 Tout élément d’une SDL sauf le dernier a un successeur.
L’ajout et la suppression sont les opérations de base des
SDL.
Nous allons voir les structures de données abstraites
linéaires usuelles et leurs différentes représentations
physiques.
247
Les piles
Définition
Une pile (stack en anglais)est une suite finie,
éventuellement vide, d’éléments de même type, dans
laquelle les éléments sont consultés, insérés (empilés) et
supprimés(dépilés) toujours à une seule extrémité
appelée sommet.
248
Les piles
Définition
L’ensemble des éléments d’une pile constitue son corps.
Une pile est constituée donc d’un corps et d’un sommet.
Si les éléments d’une pile sont de type E, on dit que le
type de la pile est « pile de E ».
Les piles ont un fonctionnement de type LIFO (Last In
First Out): dernier entré, premier sorti.
Modèle de rangement de données dans lequel :
la dernière donnée entrée est la première à sortir
pour obtenir une donnée, il faut enlever toutes celles qui
sont au dessus
249
Les piles
Définition
Les piles ont un fonctionnement de type LIFO (Last In
First Out): dernier entré, premier sorti.
250
Les piles
Spécification fonctionnelle
 Opérations
 Soient PILE le type pile et TE le type des éléments de la
pile, on a les opérations suivantes :
Opération Type
nouvellePile: PILE
Construction
crée une pile vide
empiler(push) : PILE x TEPILE
ajoute un élément à une pile
Modification
dépiler (pop): PILE PILE
retire d’une pile l'élément le plus récent
sommet: PILE  TE
retourne l'élément le plus récent de la pile
longueur : PILE  ENTIER
retourne le nombre d’éléments de la pile Consultation
estvide : PILE  BOOLEEN
teste si une pile est vide
estpleine : PILE  BOOLEEN
teste si une pile est pleine
251
Les piles
 Propriétés
 Soient p une pile, e un élément et pilevide la pile vide:
estvide(pileVide) = vrai
estvide(empiler(p,e)) = faux
sommet (empiler (p,e)) = e
dépiler (empiler (p, e)) = p
 Représentations physiques des piles
 Représentation statique
 On représente naturellement une pile par un tableau
muni d’un indicateur du sommet de pile.
252
Les piles
Représentations physiques des piles
 On représente naturellement une pile par un tableau
muni d’un indicateur du sommet de pile.
 Déclaration
CONST MAXPILE = . . . (* Hauteur maximale d’une pile*)
TYPE
Ttab = TABLEAU[MAXPILE] DE TE; (* tableau d’éléments de TE *)
PILE = ENREGISTREMENT
elements: Ttab; (* éléments de la pile*)
isommet: 0..MAXPILE;(* l’indice du sommet*)
FINENR
avec la convention que isommet = 0 indiquera que la pile est vide.
 TE= entier, réel, caractère, chaîne de caractères,
booléen, tableau, pointeur, pile ou file, ….
253
Les piles
 Déclaration
 Exemple:
 Définition des opérations
(* créer une pile vide - fonction *) (* créer une pile vide –procédure*)
FONCTION nouvellePile ( ) : PILE PROCEDURE nouvellePile (E/S p: PILE )
VAR p : PILE ; DEBUT
DEBUT
p.isommet 0 ;
p.isommet 0 ; FIN
RETOURNER p ;
FIN
(* Fonction estvide *) (* Fonction estpleine
*)
FONCTION estvide (p: PILE):BOOLEEN FONCTION estpleine(p: PILE):BOOLEEN
DEBUT
DEBUT
RETOURNER (p.isommet=0) ; RETOURNER 254
Les piles
(*empiler sous forme de fonction*) (* empiler sous forme de procédure*)
FONCTION empiler (p :PILE, e :TE) :PILE PROCEDURE empiler( E/Sp: PILE, e :TE)
DEBUT DEBUT
SI (NON estpleine(p)) ALORS SI (NON estpleine(p)) ALORS
p.isommet  p.isommet +1; p.isommet p.isommet
p.elements[p.isommet]e; +1;
SINON p.elements[p.isommet]
ECRIRE(Pile pleine); e;
FINSI SINON
RETOURNER p; ECRIRE(Pile pleine);
FIN FINSI
FIN
255
Les piles
 Représentation statique )
(* dépiler sous forme de fonction*) (* dépiler sous forme de procédure*)
FONCTION dépiler (p : PILE):PILE PROCEDURE depiler( E/Sp: PILE)
DEBUT DEBUT
SI (NON estvide(p)) ALORS SI (NON estvide(p)) ALORS
p.isommetp.isommet -1; p.isommet p.isommet -
1;
SINON SINON
ECRIRE(Pile vide); ECRIRE(Pile vide);
FINSI FINSI
RETOURNER P ; FIN
FIN (* Fonction sommet *)
FONCTION sommet (p :PILE) :TE
(*La longueur de la pile*)
DEBUT
FONCTION longueur (p : PILE) : ENTIER SI (p.isommet > 0) ALORS
DEBUT RETOURNER
RETOURNER p.isommet ; p.element [p.isommet];
FIN FINSI
FIN
256
Les piles
 Représentation dynamique(pile dynamique)
 Chaque élément de la pile est représenté par une
cellule
(appelée nœud ou maillon ou doublet) contenant un ou
plusieurs champs représentant l’élément et un pointeur
sur l’élément suivant.
 La pile elle-même est représentée par un pointeur sur la
cellule contenant le dernier élément inséré.
257
Les piles
 Représentation dynamique
 Déclaration
TYPE
CELLULE = ENREGISTREMENT
epile : TE ; (* élément
de la pile *)
spile : CELLULE;
(*pointeur sur l’élément suivant*)
FINENR
PILE = CELLULE;(* type pointeur sur cellule, représentant les piles *)
La pile vide est indiquée par p = NIL.

258
Les piles
 Il n’y a pas de pile pleine pour les piles dynamiques; la
seule possibilité de ne pas pouvoir ajouter un élément
c’est d’avoir une mémoire pleine.
(* créer une pile vide - fonction*) (* créer une pile vide - procédure*)
FONCTION nouvellePile ( ) : PILE PROCEDURE nouvellePile (S p :PILE)
VAR p:PILE; DEBUT
DEBUT pNIL ;
p NIL; FIN
RETOURNER p;
(* Fonction sommet *)
FIN
FONCTION sommet (p : PILE) : TE
(* Fonction estvide*)
DEBUT
FONCTION estvide(p: PILE) : BOOLEEN
SI (NON estvide(p)) ALORS
DEBUT
RETOURNER p
RETOURNER p = NIL;
.epile;
FIN
FINSI
FIN 259
Les piles
(* empiler sous forme de fonction*)
FONCTION empiler(p : PILE, e: TE) : PILE
VAR ptmp: CELLULE;
DEBUT
ALLOUER (ptmp); (*crée un emplacement pour une cellule et affecte son adresse à
tmp*)
ptmp.spile p;
ptmp.epile e ;
p  ptmp;
RETOURNER p ;
FIN
(* empiler sous forme de procédure*)
PROCEDURE empiler(E/S p :PILE, e: TE)
DEBUT
ALLOUER (ptmp); (*crée un emplacement pour une cellule et affecte son adresse à
tmp*)
ptmp.spile p ;
ptmp.epile e ;
p ptmp;
260
FIN
Les piles
(* depiler sous forme de fonction*)
(* depiler sous forme de procédure*)
FONCTION depiler(p : PILE) : PILE
PROCEDURE depiler(E/S p :PILE)
DEBUT
DEBUT
SI(NON estvide(p) ALORS
SI(NON estvide(p) ALORS
ptmpp ;
ptmpp ;
p  p.spile;
p p.spile;
LIBERER(ptmp);
LIBERER(ptmp);
SINON
SINON
ECRIRE(Pile vide);
ECRIRE(Pile vide);
FINSI
FINSI
RETOURNER p ;
FIN
FIN
261
Les piles
(* Fonction longueur*)
FONCTION longueur (p : PILE) : ENTIER
VAR ptmp : CELLULE ;
cpt :ENTIER ;
DEBUT
ptmp p ;
cpt0 ;
TANT QUE (ptmp ≠NIL) FAIRE
cpt  cpt+1 ;
ptmp  ptmp.spile ;
FINTQ
RETOURNER cpt ;
FIN
262
Les piles
Principales utilisations des piles
 Modélisation des piles (de cartes, de papiers, . . . )
Traitement des appels de sous-programmes (pile
d’exécution):
gestion des adresses de retour, nécessaire dans le
cas de sous-programmes récursifs…
Exemple: Un algorithme A appelle une procédure B, qui
appelle elle-même une procédure C qui appelle une
fonction D. La pile du programme va évoluer comme
suit:
263
Les piles
Traitement des appels de sous-programmes
Exemple: Un algorithme A appelle une procédure B, qui
appelle lui-même une procédure C qui appelle une
fonction D. La pile du programme va évoluer comme suit:
1. Lancement de A pile vide.
2. Appel de B par A l'état de A est empilé.
3. Appel de C par B l'état de B est empilé sur A.
4. Appel de D par C l'état de C est empilé sur B.
5. Fin de D dépilage de l'état de C et poursuite de C.
6. Fin de C dépilage de l'état de B et poursuite de B.
7. Fin de B dépilage de l'état de A et poursuite de A.
L’état d’un sous-programme représente l’espace mémoire utilisé
par ce sous-programme.
264
Les piles
Analyse des expressions par un compilateur
Journalisation des mises à jour pour réaliser la fonction
“undo” (logiciels de bureautique par exemple)
Toutes les fois où l’information importante est la dernière
rangée (ou l’avant dernière, ou . . . )
265
Les files
Définition
Une file est une suite finie, éventuellement vide,
d’éléments de même type dans laquelle les insertions (
enfilements) sont faites à une extrémité appelée queue
et les suppressions (défilements) à l’autre extrémité
appelée tête.
266
Les files
Définition
Les files fonctionnent selon le modèle FIFO (First In First
Out).
267
Les files
 Opérations
 Soient FILE le type file et TE le type des éléments de la
file, on a les opérations suivantes :
Opération Type
nouvelleFile:  FILE
Construction
crée une file vide
enfiler : FILE x E  FILE
ajoute un élément en queue de file
Modification
défiler : FILEFILE
supprime l'élément en tête de file
premier: FILE  TE
retourne l'élément en tête de file
longueur : FILE ENTIER
retourne le nombre d’éléments de la file
estvide : FILE  BOOLEEN Consultation
teste si une file est vide
estpleine : FILE  BOOLEEN
teste si une file est pleine
268
Les files
 Propriétés
 Soient f une file, e un élément et filevide la file vide:
estvide(fileVide) = vrai ;
estvide(enfiler(f, e)) = faux ;
estvide(f)  premier(enfiler(f, e)) = e ;
NON estvide(f)  premier(enfiler(f, e)) = premier(f);
estvide(f)  défiler(enfiler(f, e)) = fileVide ;
NON estvide(f)  défiler(enfiler(f, e)) =
enfiler(défiler(f), e)
269
Les files
Représentations physiques des files
 Comme pour les piles, la file peut être représentée par
un tableau et deux index pour identifier les extrémités.
 Déclaration
CONST MAXFILE = . . . (* Longueur maximale d’une file*)
TYPE
Ttab =TABLEAU[MAXFILE] DE TE;(*tableau d’éléments de TE *)
FILE = ENREGISTREMENT
elements: Ttab; (* éléments de la file*)
itete, iqueue: 0..MAXFILE;(* indices des
éléments en tête et
en queue de file*)
FINENR
La file est vide si itete = iqueue = 0 et pleine si iqueue = MAXFILE
270
Les files
(* Créer une file vide - procédure *) (* Créer une file vide - fonction*)
PROCEDURE nouvelleFile(E/S f : FILE) FONCTION nouvelleFile( ) : FILE
DEBUT VAR f : FILE ;
f.itete 0 ; DEBUT
f.iqueue  0 ; f.itete 0 ;
FIN f.iqueue  0 ;
RETOURNER f ;
(* Fonction estvide*) FIN
FONCTION estvide(f :FILE) :BOOLEEN
DEBUT
RETOURNER (f.itete=0) ; (* Fonction premier*)
FIN FONCTION premier(f: FILE):E
DEBUT
(* Fonction estpleine*) SI (NON estvide(f)) ALORS
FONCTION estpleine(f :FILE) :BOOLEEN RETOURNER
DEBUT f.elements[f.itete];
RETOURNER (f.iqueue=MAXFILE) FINSI
; FIN
FIN
271
Les files
(* enfilement*) (* défilement*)
PROCEDURE enfiler(E/S f :FILE, e : TE) PROCEDURE defiler(E/S f :FILE)
DEBUT DEBUT
SI (NON estpleine(f)) ALORS SI (NON estvide(f)) ALORS
f.iqueue  f.iqueue + 1 SI (f.itete = f.iqueue)
; ALORS
f.elements[f.iqueue]  f.itete 0;
e; f.iqueue 0;
SI (f.itete = 0) ALORS SINON
f.itete = f.itete  f.itete
f.iqueue ; +1 ;
FINSI FINSI
SINON SINON
(* Fonction longueur*)ECRIRE(File pleine) ; ECRIRE(File vide) ;
FONCTION
FINSI longueur(f :FILE) :TE FINSI
VAR lg :entier ; FIN
DEBUT
lg  0 ;
SI(non est_vide(f)) ALORS
272
Les files
FONCTION longueur(f :FILE) :ENTIER
VAR lg :entier ;
DEBUT
lg  0 ;
SI(NON estvide(f)) ALORS
lg (f.iqueue – f.itete)
+1;
FINSI
RETOURNER lg ;
FIN
273
Les files
 Un inconvénient de cette représentation que la
procédure
enfiler peut répondre « file pleine » alors que
physiquement qu’il existe encore de la place. D’où l’idée
de rendre circulaire le tableau.
Reprendrons la définition des opérations avec cette 274

Les files
(* Fonction longueur *)
FONCTION longueur(f :FILE) :ENTIER
(* Fonction estpleine*)
VAR lg :entier ; FONCTION estpleine(f :FILE) :BOOLEEN
DEBUT DEBUT
lg  0 ; RETOURNER
(longueur(f)=MAXFILE) ;
SI(NON estvide(f)) ALORS FIN
SI(f.itete ≤ iqueue)nALORS
lg (f.iqueue – f.itete)+1;
SINON
lg (f.iqueue + MAXFILE
– f.itete)+1;
FINSI
FINSI
RETOURNER lg ;
FIN
275
Les files
(* enfilement*)
PROCEDURE enfiler(E/S f :FILE, E e: TE)
Cas particuliers
DEBUT
SI(longueur(f) < MAXFILE) ALORS
SI(estvide(f))ALORS
f.itete 1;
FINSI
SI(f.iqueue = MAXFILE) ALORS
f.iqueue 1;
SINON
f.iqueue  f.iqueue +1;
FINSI
f.elements[f.iqueue]  e;
SINON
ECRIRE(File pleine!);
FINSI
FIN
276
Les files
(* défilement *)
PROCEDURE defiler(E/S f :FILE) Cas particuliers
DEBUT
SI(NON estvide(f)) ALORS
SI(f.itete =
f.iqueue)ALORS
f.itete 0;
f.iqueue 0;
SINON
SI(f.itete =
MAXFILE) ALORS
f.itete
1;
SINON
f.itete
 f.itete +1;
FINSI
FINSI
277
Les files
 Déclaration
TYPE
efile : TE ; (* élément
de la file *)
sfile : CELLULE;
FINENR
ptete: CELLULE;(* pointeur vers la
tête de la file *)
pqueue: CELLULE;(* pointeur vers
la queue de la file *)
FINENR
278
Les files
(* Créer une file vide - procédure *) (* Créer une file vide - fonction*)
PROCEDURE nouvelleFile(E/S f : FILE) FONCTION nouvelleFile( ) : FILE
DEBUT VAR f : FILE ;
f.itete NIL ; DEBUT
f.iqueue  NIL ; f.itete NIL ;
FIN f.iqueue  NIL ;
(* Fonction estvide*) RETOURNER f ;
FONCTION estvide(f :FILE) :BOOLEEN FIN
DEBUT
RETOURNER (f.itete=NIL) ; (* Fonction premier*)
FIN FONCTION premier(f: FILE):TE
DEBUT
SI (NON estvide(f)) ALORS
RETOURNER
f.itete.efile;
FINSI
FIN
279
Les files
(* enfilement*) (* défilement *)
PROCEDURE enfiler(E/S f :FILE, E e: TE) PROCEDURE defiler(E/S f :FILE)
VAR p:CELLULE; VAR p:  CELLULE;
DEBUT DEBUT
ALLOUER(p); SI(NON estvide(f) ALORS
p.efile  e; p f.ptete;
p.sfile  NIL; f.ptete  f.ptete.sfile;
SI(estvide(f)) ALORS SI(f.ptete =NIL) ALORS(*s’il y
f.pqueue  p; avait un seul élt*)
f.ptete p; f.pqueue  NIL;

SINON FINSI
f.pqueue.sfile  p; LIBERER(p);
f.pqueuep; SINON
FINSI ECRIRE(File vide);
FIN FINSI
FIN 280
Les files
FONCTION longueur (p : FILE) : ENTIER
VAR p : CELLULE ;
cpt :ENTIER ;
DEBUT
p f.ptete ;
cpt0 ;
TANT QUE (p ≠NIL) FAIRE
cpt  cpt+1 ;
p  p.sfile ;
FINTQ
RETOURNER cpt ;
FIN
281
Les files
 On peut améliorer la représentation dynamique en
permettant qu’un élément de la file connaisse, non
seulement son suivant mais aussi l’élément qu’il suit
c’est-à-dire son prédécesseur.
282
Les files
 On peut améliorer la représentation dynamique en
permettant qu’un élément de la file connaisse, non
seulement son suivant mais aussi l’élément qu’il suit
c’est-à-dire son prédécesseur.
 Déclaration
TYPE CELLULE = ENREGISTREMENT
efile : TE ; (* élément
de la file *)
sfile : CELLULE;
pfile:CELLULE;
(*pointeur sur l’élément précèdent*)
FINENR
ptete: CELLULE;(* pointeur vers la
283
tête de la file *)
Les files
 Définition des opérations (* défilement *)
(* enfilement*)
PROCEDURE defiler(E/S f :FILE)
PROCEDURE enfiler(E/S f :FILE, E e: TE)
VAR p: 
CELLULE;
VAR p:CELLULE;
DEBUT
DEBUT
SI(NON estvide(f) ALORS
ALLOUER(p);
p f.ptete;
p.efile  e;
p.sfile  NIL; f.ptete  f.ptete.sfile;
p.pfile NIL; SI(f.ptete =NIL) ALORS(*s’il y
avait un seul élt*)
SI(estvide(f)) ALORS
f.pqueue  NIL;
f.pqueue  p;
SINON
f.ptete p;
f.ptete.pfileNIL;
SINON
p.pfile f.pqueue; FINSI
f.pqueue.sfile  p; LIBERER(p);
f.pqueuep; SINON
FINSI ECRIRE(File vide);
FIN FINSI 284
Les files
Principales utilisations des files
Les systèmes d’exploitation ont recours à la structure de
données file pour gérer l’accès à une ressource
partageable:
File des requêtes d’impression (serveur d’impression)
File des processus en attente d’un processeur
(scheduler ou ordonnanceur)
Support au protocole producteur - consommateur
entre deux processus asynchrones: un processus P
produit des données envoyées à C. Une file stocke les
données lorsque P produit plus vite que C ne
consomme.
285
Les files
Stock de données périssables
Files d’attente de supermarché, trafic automobile,…
286
Les files
D’une manière générale, on utilise une file chaque
fois qu’il s’agit de gérer l’allocation d’une ressource à
plusieurs clients.
Exemple: Traitement des requêtes reçues par un serveur
de Bases de Données:
 un module de communication lit les requêtes sur le
réseau, les stocke dans une file, libère la connexion
et se remet à écouter;
 un module de traitement prélève les requêtes et les
traite (ou les répartit sur des sous serveurs), puis
stocke la réponse;
 un module de communication prélève les réponses et
les envoie
287
Les listes
Définition
Une liste est une structure de données linéaire dans
laquelle la consultation, l’insertion et la suppression
peuvent se faire à un endroit quelconque tout en
maintenant la linéarité de la structure de données.
 Les piles et les files sont des cas particuliers de listes.
288
Les listes
 Opérations
 Soient LISTE le type liste et TE le type des éléments de
la
Opération Type
liste, on a les opérations
nouvelleListe: LISTE suivantes : Construction
crée une liste vide
ajouter : LISTE x ENTIER x TELISTE
ajoute un élément à une liste à un rang donné
Modification
supprimer: LISTE x ENTIERLISTE
retire d’une liste l'élément d’un rang donné
ieme: LISTE x ENTIER  TE
retourne l'élément de la liste d’un rang donné
longueur : LISTE  ENTIER
retourne le nombre d’éléments de la liste Consultation
estvide : LISTE  BOOLEEN
teste si une liste est vide
estpleine : LISTE  BOOLEEN
teste si une liste est pleine
289
Les listes
 Propriétés
 Soient l une liste, e un élément et listevide la pile vide:
longueur(listevide) = 0
r, 1≤r≤ longueur(l), longueur(supprimer(l,r))=longueur(l)-1
r, 1≤r≤ longueur(l), longueur(ajouter(l,r,e))=longueur(l)+1
r, r<1 ou r>longueur(l),
r, 1≤r≤ longueur(l) et 1≤i<r, ieme(supprimer(l,r),i)=ieme(l,i)
r, 1≤r≤ longueur(l) et r≤i≤longueur(l)-1,
ieme(supprimer(l,r),i) =
ieme(l, i+1)
r, r < 1 ou r > longueur(l), , =supprimer(l,r)
r, 1≤r≤ longueur(l)+1 et 1≤i<r,
ieme(ajouter(l,r,e),i)=ieme(l,i)
r, 1≤r≤ longueur(l)+1 et r = i, ieme(ajouter(l,r,e),i)=e
r, 1≤r≤ longueur(l)+1 et r<i≤longueur(l)+1,
290
Les listes
Représentations physiques des listes
 On représente naturellement une liste par un tableau
muni d’un indicateur de la longueur de la liste.
 Déclaration
CONST MAXLISTE = . . . (* Longueur maximale d’une liste*)
TYPE
Ttab =TABLEAU[MAXLISTE] DE TE;(*tableau d’éléments de TE *)
LISTE = ENREGISTREMENT
elements: Ttab; (* éléments de la liste*)
lg: 0..MAXLISTE;(*longueur de la liste*)
FINENR
La liste est vide si lg= 0 et pleine si lg= MAXFILE
291
Les listes
(* Créer une liste vide - procédure *) (* Créer une file vide - fonction*)
PROCEDURE nouvelleListe(E/S l : LISTE) FONCTION nouvelleListe( ) : LISTE
DEBUT VAR l : LISTE;
l.lg 0 ; DEBUT
FIN l.lg 0 ;
RETOURNER l ;
FIN
FONCTION estvide(l :LISTE) :BOOLEEN
DEBUT
RETOURNER (l.lg=0) ; (* Fonction longueur *)
FIN FONCTION longueur(l: LISTE):ENTIER
DEBUT
(* Fonction estpleine*) RETOURNER l.lg;
FONCTION estpleine(l :LISTE) :BOOLEEN FIN
DEBUT
RETOURNER (l.lg=MAXLISTE) ;
FIN
292
Les listes
(* consultation un élément *)
FONCTION ieme(E l : LISTE, E r:ENTIER): TE
DEBUT (* supprimer un élément *)
SI(r≥1 ET r≤l.lg ) ALORS PROCEDURE supprimer(E/S l:LISTE, E r: ENTIER)
RETOURNER l.elements[r] ; VAR i: ENTIER;
FINSI DEBUT
FIN SI(NON estvide(l)) ALORS
SI(r≥1 ET r ≤l.lg) ALORS
POUR i DE r+1 A l.lg
FAIRE
l.elements[i-1]
l.elements[i];
FINPOUR
l.lgl.lg-1;
SINON
ECRIRE(Rang hors
intervalle);
FINSI
SINON
ECRIRE( Liste vide ); 293
Les listes
(* Ajouter un élément *)
PROCEDURE ajouter(E/S l:LISTE, E r: ENTIER, E e: TE)
VAR i: ENTIER;
DEBUT
SI(NON estpleine(l)) ALORS
SI(r≥1 ET r ≤l.lg+1) ALORS
POUR i DE l.lg A r
DECROISSANT FAIRE
l.elements[i+1]
l.elements[i];
FINPOUR
l.elements[r]e;
l.lgl.lg+1;
SINON
ECRIRE( Rang d’insertion
hors intervalle);
FINSI
SINON
ECRIRE( Liste pleine );
294
FINSI
Les listes
o Représentation par simple chaînage
 Une liste peut être représentée par un ensemble de
cellules où chacune contient en plus de la valeur d’un
élément, l’adresse de l’élément suivant.
 La liste est alors donnée par le pointeur du premier
élément.
295
Les listes
 Déclaration
TYPE
eliste : TE ; (* élément de
la liste*)
sliste: CELLULE;
FINENR
LISTE = CELLULE; (* type pointeur sur cellule, représentant les listes*)
296
Les listes
(* Créer une liste vide - procédure *) (* Créer une file vide - fonction*)
PROCEDURE nouvelleListe(E/S l : LISTE) FONCTION nouvelleListe( ) : LISTE
DEBUT VAR l : LISTE;
l NIL; DEBUT
FIN lNIL;
RETOURNER l ;
FIN
FONCTION estvide(l :LISTE) :BOOLEEN
DEBUT
RETOURNER (l=NIL) ;
FIN
297
Les listes
(* Ajouter un élément *)
PROCEDURE ajouter(E/S l:LISTE, E r: ENTIER, E e: TE)
VAR i: ENTIER;
c, p, q:CELLULE;
DEBUT
SI(r≥1 ET r ≤longeur(l)+1) ALORS
ALLOUER(c); c.elistee;
SI(r = 1) ALORS (*insertion en tête de
liste *)
c.slistel; lc;
SINON
pNIL; q  l;
POUR i DE 1 A r-1 FAIRE
pq; qq.sliste;
FINPOUR
p.slistec; c.slisteq;
FINSI
SINON
ECRIRE( Rang d’insertion hors 298
Les listes
(* supprimer un élément *)
PROCEDURE supprimer(E/S l:LISTE, E r: ENTIER)
VAR i: ENTIER;
p, q:CELLULE;
DEBUT
SI(r≥1 ET r ≤longueur(l)) ALORS
SI(r = 1) ALORS (*suppression en tête
de liste *)
ql; ll.sliste;
SINON
pNIL; q  l;
pq; qq.sliste;
FINPOUR
p.slisteq.sliste;
FINSI
LIBERER(q);
SINON
ECRIRE( Rang d’insertion hors 299
Les listes
(* consulter un élément *)
FONCTION ieme(E l:LISTE, E r:ENTIER): TE
VAR i: ENTIER;
p:CELLULE;
DEBUT
SI(r≥1 ET r ≤longueur(l)) ALORS
pl;
pp.sliste;
FINPOUR
RETOURNER p.eliste;
FINSI
FIN
300
Les listes
(* Fonction longueur *)
FONCTION longueur(l: LISTE):ENTIER
VAR p : CELLULE ;
cpt :ENTIER ;
DEBUT
p l;
cpt0 ;
TANT QUE (p ≠NIL) FAIRE
cpt  cpt+1 ;
p  p.sliste ;
FINTQ
RETOURNER cpt ;
FIN
301
Les listes
o Représentation par double chaînage
 Dans cette représentation, chaque cellule est liée à ses
deux cellules voisines.
 Ainsi chaque cellule va contenir un pointeur
supplémentaire, le pointeur vers l’élément précédent.
 La liste est alors donnée par les pointeurs des premier
et
dernier éléments
302
Les listes
303
Les listes
 Déclaration
TYPE
eliste : TE ; (* élément de
la liste *)
sliste : CELLULE;
pliste:CELLULE;
(*pointeur sur l’élément précédent*)
FINENR
LISTE = ENREGISTREMENT
pdebut: CELLULE;(* pointeur vers le
début de la liste *)
pfin: CELLULE;(* pointeur vers la 304
fin
Les listes
En exercices
305
Les dèques
Définition
Une dèque est une liste possédant à la fois les propriétés
d’une pile et d’une file.

Une dèque est une collection d’objets offrant la
possibilité:
d’insérer un nouvel objet avant le premier ou après le
dernier;
d’extraire le premier ou le dernier objet.
Le mot dèque vient de l’anglais double ended queue
306
Les dèques
 Opérations
 Soient DEQUEUE le type dèque, TE le type des
éléments de la dèque et SENS=gauche,droite, on a les
opérations suivantes :
Opération Type
nouvelleDeque: DEQUEUE
Construction
crée une dèque vide
endequer : DEQUEUE x TE x SENSDEQUEUE
ajoute un élément à une dèque à un bout donné
Modification
dedequer: DEQUEUE x SENS DEQUEUE
retire d’une dèque l’élément à un bout donné
extremite: DEQUEUE x SENS  TE
retourne l'élément de la dèque à un bout donné
longueur : DEQUEUE ENTIER
retourne le nombre d’éléments de la dèque Consultation
estvide : DEQUEUE BOOLEEN
teste si une dèque est vide
estpleine : DEQUEUE BOOLEEN
teste si une dèque est pleine
307
Les dèques
Représentations physiques des dèques
En exercices
308

Présentation Compléments Algo

Transféré par

Informations du document

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

Présentation Compléments Algo

Transféré par

Droits d'auteur :

Formats disponibles

Cours: Compléments

 Types de données dérivés

 Structures de données linéaires

 Cours Introduction à l’algorithmique

Exempleno : REEL ; (* note à insérer *)

pos : ENTIER ; (* position d’insertion *)

PROCEDURE triParMinimumSuccessif (E/S T :NOTE,E n :ENTIER)

PROCEDURE triParMaximumSuccessif (E/S T :NOTE,E n :ENTIER)

En résumé, on parcourt le tableau T (i variant de 2 à n) et à

trié sur [1..borneSup-1]

i=5 i=4 i=3 i=2

Cette syntaxe déclare <nom_tableau> comme un tableau

La première syntaxe déclare une chaîne de caractères de

Renvoie une nouvelle chaîne constituée de la concaténation des

Un type intervalle est un sous-ensemble de valeurs

consécutives d'un type hôte.

Le type hôte doit être un type ordinal c’est-à-dire un type

admettant les opérateurs pred, succ et ord (le précédent,

successeur et le numéro d'ordre dans le codage): entier,

Bmin et Bmax sont des constantes du même type, et sont

2°) Déclarer en Algo : T, Section, ch, a et PI

Remarque: Un enregistrement représente un objet matériel

Les enregistrements sont les occurrences de

CONST MAXE  100: ENTIER;

La mémoire est constituée de petites cases-mémoire

On dit aussi que A est l’objet pointé.

Si un pointeur p pointe sur une variable x, alors p peut être

 Liste doublement chaînée

Le tableau doit être libéré après utilisation :

consomme du temps et de l’espace

Définir le type enregistrement Tproduit qui permet de définir les nœuds de la

(2) Affecter la valeur NIL à cette variable

(*Sous forme de fonction*) (*Sous forme de procédure*)

TListeProduit CreerProdVide() void CreerProdVide(S

(2) Donner la valeur à l’information contenue dans cette

(3) Assigner au champ "suivant" de la nouvelle cellule,

(4) Définir la nouvelle cellule comme cellule de tête

(2) Donner la valeur à l’information contenue dans cette

(3) Assigner au champ "suivant" de la nouvelle cellule,

(4) Si la liste est vide (ie tete =NIL)

(4.2.) Parcourir la liste jusqu’à la dernière cellule.

(4.3.) Assigner au champ "suivant" de la cellule

(3) si liste vide (ie tete =NIL) ou position d’insertion pos =1

(3.2.) Définir la nouvelle cellule comme cellule de tête

(3.2.) Parcourir la liste jusqu’à la cellule de position pos-1.

(1) si liste non vide (ie tete ≠ NIL)

(1.2) Assigner à tete son suivant

(1.3) Libérer l’espace occupé par la cellule qui était en tête

(1) si liste non vide (ie tete ≠ NIL)

(1.2) Parcourir la liste jusqu’à la dernière cellule

(1) si liste non vide (ie tete ≠ NIL) et pos ≠ 1

(1.4) Assigner au champ "suivant" de precedent le

(1.5) Libérer l’espace occupé par la cellule de rang pos

PROCEDURE InsertTete(E/S L: Liste)

désignation, sa couleur et sa quantité en stock, alors

Un index est unique, si à chaque valeur de la clé d’accès

où nom_de_fichier_physique est soit une constante chaîne

soit une variable chaîne. Ce nom peut comprendre le

où mode_Ouverture est une chaîne de caractères qui

Cette syntaxe écrit à partir de la position courante de la tête

Cette syntaxe copie dans variable l’élément courant du

Exemple: Ecrire une procédure permettant d’afficher la liste

La fermeture d’un fichier est obligatoire pour être sûr

PROCEDURE CopieSal(E fe : FI_EMPLOYES, S T_Salaire: SALAIRES, S n: ENTIER)

(Sous forme de fonction) (Sous forme de procédure)