MINISTÈRE DE L’ENSEIGNEMENT SUPÉRIEUR

ET DE LA RECHERCHE SCIENTIFIQUE

UNIVERSITE DE LABÉ
FACULTE DES SCIENCES ET TECHNIQUES
DEPARTEMENT INFORMATIQUE

SUPPORT DU COURS D’ALGORITHMIQUE

2.Structures de données & Algorithmes:

2.1 Vecteurs & tableaux
2.2 Fichiers

Auteur : Dr. Ibrahima CAMARA

Labé, Octobre 2021

Page 1
1. VECTEURS& TABLEAUX
1.1. Notions de vecteur
En plus des variables de types simples, il arrive très souvent que l’on soit amené à
considérer un ensemble de variables de même type, auxquelles on accède soit
directement par leur numéro d’ordre, soit en les parcourant toutes dans l’ordre.
1.1.1. Définitions formelles
Soient :
- un ensemble quelconque : appelé ensemble des valeurs, noté par E,
- un entier n appelé nombre d’éléments du vecteur,
- un intervalle I de N tel que I=[1…n], avec n>=0.
Définition 1 : on appelle vecteur, une application V de I dans E où I est appelé ensemble
des indices.
Les éléments de E peuvent être des valeurs de type simple (entier, caractère, booléen et
chaîne de caractères). Mais ils peuvent être aussi de valeurs de type structuré,
composées de valeurs de type simple ou structuré.
Exemple 1 :
Type
tdate : structure
Jour, mois, an : entier ;
Fin structure ;
tpersonne : structure
Nom : chaîne(20) ;
Adresse : chaîne(20) ;
Naissance : tdate ;
Marié : booléen ;
Nb_enfants : entier ;
Finstructure ;
On vient de définir :
- un type tdate composé de trois nombres (jour, mois et an ) ,
- un type tpersonne composé d’un nom, d’une adresse(chaîne de 20 caractères au plus),
- une variable naissance de type tdate,
- une variable booléenne marié,
- une variable Nb-enfants, indiquant le nombre d’enfants de la personne.
On dit que personne comporte cinq champs : Nom, Adresse, Marié et Nb_enfants.
Pour sélectionner un champ on utilise la notation suivante :
nom de variable .nom du champ ;
Par exemple si Pers est une variable de type tpersonne, on écrira : Pers.Nom, Pers.
Adresse, Pers.Marié, Pers.Nb_enfants pour accéder aux différents champs de la variable
structurée Pers. Pour acceder aux sous-champs tdate , on écrit Pers.Naissance.an si nous
voulons accéder à l’année.

Page 2
Les variables Pers. Nom, Pers.Adresse … sont utilisées comme des variables
élémentaires de type donné.
Les éléments de E peuvent aussi être eux-mêmes des vecteurs et l’on pourra ainsi définir
des ensembles à plusieurs dimensions par exemple des matrices.
L’ensemble des indices I peut être vide (n=0), le vecteur est alors vide. L’indice le plus
petit (ici 1) s’appelle borne inférieure et le plus grand (ici n ) s’appelle borne supérieure.
La taille d’un vecteur est le nombre d’éléments de ce vecteur ou le nombre d’éléments
de l’ensemble des indices. Si I=[1…n], la taille du vecteur est égale à n.

1.1.2. Notations
- un vecteur est noté par le nom de la variable de type vecteur. Soit par exemple V.
- un élément d’un vecteur est noté V( i ) avec i[1…n].
- Schématiquement on représente un vecteur par :

Indice 1 2 3 n
V V( 1 ) V( 2 ) V( 3 ) ……………………

1.1.3. Indiçage
Soit un vecteur V[1…n] :
- pour tout indice ou index i  [1…n ], l’opération d’indiçage notée V( i ) délivre la
valeur de l’élément d’indice i du vecteur ; cette valeur peut être affectée à une variable.
Par exemple
A  V( i ). De même on peut ranger une valeur A dans le i-ème élément par affectation
V( i )  A.
- le résultat de V( i ) est indéfini si i  [1…n].
Exemple 2 :
Indice 1 2 3 4 5 6
V A B Z A C D

V( 2 )= ‘B’ ; V( -4 )= non défini ; V( 0 )= non défini ; V( 4 ) =’A’ ; V( 5 )=’C’ ; V(7 )=

non défini.
Remarque : Il y a une analogie entre les vecteurs et tableaux habituellement utilisés en
mathématiques.
1.1.4. Déclaration
Pour déclarer un vecteur, on supposera toujours qu’il existe une définition de type telle
que :
Type tvect = tableau ( 1… nmax ) de t ; où t peut être de type simple, structuré ou
même vecteur ; nmax est une variable représentant le nombre maximum d’éléments
possibles pour le type vecteur. En effet, il faut prévoir le nombre maximum d’éléments
du vecteur afin de réserver la place nécessaire. On dit qu’on a une gestion statique de la
mémoire.
Page 3
Avec cette déclaration, on peut ranger n’importe quel vecteur V(1..n ) tel que la borne
supérieure du vecteur n vérifie la relation : 0 < n <=nmax.
Indice 1 2 3 n nmax
Type vect ………… …………

1.1.5. Sous - vecteur.

Définition 2 On appelle sous – vecteur du vecteur V(1…n ) toute restriction de V à un
intervalle consécutif de [1…n]. Un sous – vecteur est noté comme un vecteur.
Exemple 3 : si V( 1…5 ) = ( 7 ; -20 ; 40 ; 0 ; 1 ) alors les sous – vecteurs V( 2…4 ) et
V( 1…3 ) sont formés respectivement par : ( -20 ; 40 ; 0 ) et ( 7 ; -20 ; 40 ).
Autres notations
On utilisera les notations suivantes dans les assertions :
- a V( 1…n ) signifie j  [i…n ], a = V( j ) ;
- a V( 1…n ) signifie  j  [i…n ], a  V( j ) ;
- a <V( 1…n ) signifie j  [1…n], a< V( j )
On utilisera de même les opérations : ,>, , .
On désignera par V(i…j )
- le sous - vecteur composé des éléments V( i ), V( i+1 ), ……, V( j ) si j  i ;
- le sous – vecteur vide si i > j.
1.2. Algorithmes traitant un seul vecteur
1.2.1 Algorithme de création d’un vecteur.
Pour créer un vecteur, on a deux choix toujours est-il que le vecteur a une taille
maximale bien définie.
a) Soit on connait le nombre d’élément à saisir ; dans ce cas une simple boucle
pour est utilisée :
Exemple Ecrire un algorithme qui crée et affiche un tableau de n entiers.
Algo Creation ;
Const nmax=100 ;
Type tvect=tableau(1..nmax) d’entier ;
Var i,n :entier ; V :tvect ;
Procedure creation(E/S V :tvect ) ;
Debut
Pour i de 1 à n faire
Afficher(‘V(‘,i,’)=’) ; lire(v(i)) ;
Fpour ;
Fproc ;
Procedure affichage(E V :tvect ) ;
Début
Pour i de 1 à n faire
Afficher(V(i)) ;
Fpour ;
Page 4
 Fproc ;
Début
Afficher(‘Combien d’’éléments voulez-vous saisir ?’) ;
Lire(n) ;
Si n>nmax alors
nnmax ;
fsi ;
Creation(V,n) ;
Affichage(V,n) ;
Fin.
b) Soit on ne connait pas d’avance le nombre d’élément à saisir.
Dans ce cas, il faut créer une condition d’arrêt et utliser la boucle Tant que ou la
boucle répéter.
Exemple : Ecrire un algorithme de création et d’affichage d’un repertoire
téléphonique caractérisé par le code du client formé de caractères, son nom, son
numéro de téléphone et sa ville natale. On convient de taper * comme code pour
arrêter la saisie.
Algo gestionrepertoire ;
Const nmax =100 ; arret=’*’ ;
Type Trepertoire= structure
Code : chaine(8) ;
Nom : chaine(15) ;
Tel : entier long ;
Ville : chaine(17) ;
Fstr ;
Repertoire=tableau(1..nmax) de Trepertoire ;
Var T : repertoire ; i, n : entier ;
Procedure creation(E/S T:repertoire, S n:entier);
Var i:entier;
Debut
i1;
Afficher(‘Donner le premier code ou taper * pour sortir’);
Lire(T(i).code) ;
Tant que T(i).code<> arret faire
Afficher(‘Donner le nom’) ;
Lire(T(i).nom ) ;
Afficher(‘Donner son numéro de téléphone’) ;
Lire(T(i).tel) ;
Afficher(‘Donner sa ville natale’) ;
Lire(T(i).ville) ;
Ii+1 ;
Afficher(‘Donner le code suivant ou taper * pour sortir’) ;
Page 5
 Lire(T(i).code) ;
Ftq ;
Ni-1 ;
Fproc ;
Procedure affichage(E/S T :repertoire) ;
Var i :enitier ;
Debut
Afficher(‘Code____Nom____Téléphone____Ville_’) ;
Pour i de 1 à n faire

Afficher(T(i).code :5,’|’,T(i).nom :10,’|’,T(i).tel :9,’|’,T(i).ville :9,’|’)

;
Afficher(‘----------------------------------------’) ;
Fpour ;
Fproc ;
Début
Creation(T,n) ;
Affichage(T) ;
Fin ;
1.2.2 Algorithmes de parcours d’un vecteur
Soit un vecteur V à n éléments. L’idée consiste à parcourir le vecteur dans l’ordre
croissant de ses indices. On obtient ainsi le schéma d’énumération séquentiel « de
gauche à droite » des éléments du vecteur V.
Procédure parcours(E V : tvect) ;
Var i : entier ;
Début
i1 ;
tant que i n faire
traiter V( i ) ;
i i+1 ;
fin tant que
finproc ;
où traiter est une action quelconque sur l’élément V( i ). Ou encore en introduisant
l’instruction « Pour » croissante, on aura :
Pour i de 1 à n faire
Traiter ( V( i )) ;
Fin Pour ;
On peut également définir un parcours séquentiel dans l’ordre des indices décroissants,
dit ordre de « droite à gauche ». On remplacera alors
- l’initialisation i 1 par i  n ;
- la condition d’itération i  n par i  1 ;
Page 6
- l’incrémentation i  i+1 par la décrémentation i  i – 1 .
Le schéma d’énumération séquentiel des éléments de V s’écrit dans ce cas :
In ;
Tant que i1 faire
Traiter( V( i )) ;
Ii–1;
Fin tant que ;
Qui peut aussi s’écrire, à l’aide de l’instruction « Pour » décroissante ( l’indice i est
décrémenté de 1 à chaque itération) :
Pour i de n à 1 faire
Traiter( v( i )) ;
Fin pour ;
Exemple 1 : Afficher tous les éléments d’un vecteur, dans l’ordre des indices croissants ;
Début
Pour i de 1 à n faire
Afficher ( V( i )) ;
Fin pour
Fin.
Exemple 2 : calculer la somme des éléments d’un vecteur de nombres entiers.
Fonction somme( E V : vect ) :entier ;
Var i,s ; entier ;
Début
S0 ;
Pour i de 1 à n faire
S s + V( i )
Fin pour
Somme s ;
Finfonction ;
1.2.3 Algorithmes d’accès à un élément d’un vecteur
Soit un vecteur V( 1…n ). L’accès par position est défini par la primitive d’indiçage V(
i ). L’accès associatif est le plus courant. Soit elem une variable contenant une valeur de
même type que celles contenues dans V, on veut déterminer s’il existe un indice i 
[1…n] tel que V( i ) = elem. Cet accès peut être réalisé de plusieurs manières suivant
que l’on suppose V trié ou non.
1.2.3.1 Recherche séquentielle dans un vecteur non trié
On peut écrire une fonction dont l’en – tête sera :
Fonction accès ( E V : vect ; E elem : t ) : booléen ;
Spécification { n>=0}  { résultat = elem  V( 1..n ) }.
Raisonnement par récurrence :
Supposons traités les i-1 ( 1< i  n+1 ) premiers éléments de V et que elem V( 1…i-1)
soit une assertion ;
Page 7
On a deux cas :
- i = n+1, alors elem V( 1…n ), l’algo est terminé, elem  V
- i  n on a encore deux cas :- V( i ) = elem, alors elem  V(1…i), l’algo est
terminé, elem  V.- V( i )  elem, elem  V( 1…i ), l’exécution de l’instruction i 
i+1, permet de retrouver l’assertion elem  V( 1…i1 )
Initialisation
L’exécution de l’action i  1, permet l’écriture de l’assertion : elem V( 1…i-1 ) qui
est donc un invariant.
Hypothèse : elem V( 1…i-1 )
- i = n+1  elem V( 1…n )  résultat = faux.
- In
- V( i ) = elem  elem  V( 1…n )  résultat = vrai.
- V( i )  elem  i  i+1 ;  Hypothèse
Itération : tant que ( i n ) et alors ( V( i )  elem) faire
Initialisation i  1 ;  Hypothèse.
À priori, on écrirait l’itération sous la forme :
Tant que ( in ) et (V( i )  elem ) faire…
Mais si elem V(1…n ), i atteint à la dernière itération la valeur n+1, et l’on est
amené alors à effectuer un test sur V( n+1 ), valeur indéfinie.
On introduit donc l’opérateur booléen « et alors », qui est en fait une évaluation
optimisée du « et » classique. Il s’agit simplement de constater que si le premier
terme du « et alors » est faux, il est inutile d’examiner le second terme.

A B A et alors B
Vrai Vrai Vrai
Vrai Faux Faux
Faux Non examiné Faux

La table de vérité du « et alors » est la sui

La valeur de l’opération C  A et alors B est équivalente à celle que donnerait la
séquence
Si A
Alors C  B
Sinon C  Faux
Fsi
On définit de même l’opération « ou sinon », qui correspond à l’évaluation optimisée
du « ou » classique. Si le premier terme du « ou sinon » est vrai il est inutile
d’examiner le second
La table de vérité du « ou sinon » est :

Page 8
 A B A ou sinon B
Vrai Non examiné Vrai
Faux Vrai Vrai
Faux Faux Faux
La valeur de l’opération C  A ou sinon B est équivalente à celle que donnerait la
séquence :

Si A
Alors C  Vrai
Sinon C  B
Fsi
Remarques
1. la loi de Morgan peut s’écrire pour ces opérations :
non ( A et alors B ) = ( non A ) ou sinon ( non B )
non ( A ou sinon B ) = ( non A ) et alors ( non b ).
2. De nombreux langages de programmation implémentent ces opérations soit
directement ( « and then » et « or else » de ADA ; « && » et «  » de C ) soit sous
forme d’options d’évaluation accélérée ( certains compilateurs de pascal ). S’ils
n’existent pas, on est amené à les simuler au moyen de valeurs booléennes.
L’algorithme s’écrit alors :
Fonction Accès( E V: vect ; E elem :t ) : booléen ;
Var i :entier ; trouve :booléen ;
Début
I 1 ; trouve :  faux ;
Tant que (in) et alors ( V( i )  elem ) faire
I  i +1
Fin tant que
Si i n
Alors trouve  Vrai ;
Fsi ;
Accès  trouve ;
Finfonction ;
1.2.3.2 Recherche d’un élément dans un vecteur ordonné ( trié )
Si tous les éléments consécutifs d’un vecteur vérifient la relation d’ordre
V( i – 1 )  V( i ) on dit que le vecteur est trié par ordre croissant. Dans la suite du
cours, sauf avis contraire, on appellera vecteur trié ou ordonné, un vecteur trié par ordre
croissant.
On admettra que le vecteur vide et que le vecteur ne contenant qu’un seul élément sont
triés.
D’où la définition :
- un vecteur vide ( n=0 ) est ordonné,
Page 9
- un vecteur contenant un seul élément ( n=1 ) est ordonné,
- un vecteur V( 1…n ) (n>1) est ordonné si i  [2….n], V( i-1 )  V( i ).
1.2.3.2.1 L’algorithme vérifiant qu’un vecteur est trié.
Raisonnement : il suffit de comparer tous les couples de deux éléments consécutifs en
s’arrêtant dès qu’un couple ne vérifie pas la relation d’ordre V(i-1 ) V( i ). On peut
remarquer que cet algorithme est très semblable à celui de l’accès séquentiel Accès, mais
que la valeur retournée est « vrai » si et seulement si on a bien atteint i > n. Notons que
les cas n=0 et n=1 sont correctement traités puis que la valeur initiale de i est supérieure
à n dans ces cas.
Hypothèse : V( 1…i-1 ) est trié,
I > n+1 V( 1…n ) est trié  résultat = vrai
I  n, deux cas sont possibles :
- V( i – 1 ) > V( i )  V n’est pas trié  résultat = faux,
- V( i - 1 )  V( i )  i = i+1  Hypothèse
D’où
- l’itération : tant que ( i  n ) et alors ( V( i -1 )  V( i )) faire ….
- l’initialisation : i  2 ;  Hypothèse.
- D’où la fonction :
- Fonction trié( E V(1….n ) : vect ) : booléen ;
- Var i : entier ;
Début
I2;
Tant que ( i n) et alors (V( i – 1 )  V( i )) faire
Ii+1;
Fin tant que
Si i > n
Alors trié  vrai
Sinon trié  faux
Fsi
Finfonction ;
1.2.3.2.2 Accès à un élément dans un vecteur trié.
On cherche un indice i [1…n ] tel que V( 1..i – 1 ) < elem  V( i…n ) soit une
assertion.
Ensuite ne reste-t-il plus qu’à vérifier l’égalité elem = V( i ) pour savoir si elem est
présent ou non dans le vecteur trié.
Hypothèse : V( 1…i – 1 ) < elem ;
I = n + 1  elem  V  résultat = faux ;
I  n ; deux cas sont possibles :
- V( i )  elem  V( 1…i – 1 ) < elem  V( i…n ), elem  V  elem = V( i ),
résultat = ( elem = V( i ));
- V( i ) < elem  ii + 1 ;  Hypothèse
Page 10
L’itération : tant que ( in ) et alors (V( i ) < elem ) faire ….
L’initialisation : i  1 ;  Hypothèse.
D’où la fonction :
Fonction Accès_trié( E V : vect ; E elem :t ) : booléen
Var i :entier ;
Début
I 1;
Tant que ( in ) et alors V( i ) < elem faire
I  i+1
Fin tant que
Si ( i n) et alors (V( i ) = elem)
Alors Accès_trié  vrai
Sinon Accès_trié  faux
Fsi
Finfonction ;
1.2.3.2.3 Recherche dichotomique
On cherche à écrire une fonction d’en-tête :
Fonction dicho( E V : vect ; E elem :t ) : booléen ;
Supposons le vecteur V( 1…n ) trié ( sans répétition et n 1 ) c’est à dire i [ 2…n ]
on a V( i-1 )  V( i ).
On va partitionner le vecteur V en trois sous vecteurs V( 1…m-1 ), V( m), V( m+1…n )
triés. Cette partition vérifie la relation : V( 1…m-1)  V(m)  V(m+1…n). En
comparant elem à V( m ), on peut décider , si elem n’est pas égal à V( m ), à quel sous
vecteur il appartient :
- à V( 1…m-1 ) si elem <V(m)
- à V(m+1…n) si elem > V(m).
on n’est alors amené au problème de recherche d’un élément dans un vecteur trié soit
V(1…m-1) soit V(m+1…n). Par contre si elem = V(m ), l’algorithme est terminé.
On n’est donc amené à déterminer une suite de sous vecteurs : V1, V2, …, Vk telle
que chaque sous vecteur Vi a un nombre d’éléments ( taille ) strictement inférieur à la
taille du sous vecteur précédent Vi-1. La suite des tailles est décroissante et bornée
inférieurement par zéro. Elle est donc convergente. Cette convergence se produit en
un nombre fini de pas puis que la suite est bornée par n-1.
En conclusion:
- soit on a trouvé un indice m tel que elem = V( m ) et l’algorithme est terminé.
- soit on a trouvé, en un nombre fini de pas, un sous vecteur vide, elem V et
l’algorithme est terminé.
En général, on choisit un indice m tel que la taille des deux sous vecteurs
V( 1…m-1 ) et V( m+1…n ) soit la même ( à un élément près ).

Page 11
La taille des vecteurs de la suite V1, V2, …., Vk est divisée par deux à chaque pas : n,
n/2, …., n/2k-1, on aura donc au plus « partie entière de log2(n) » sous vecteurs non
vides.
Exemple : si V est un vecteur de 9000 éléments, le nombre maximum de sous vecteurs
non vides sera égal à 13 ( 213 = 8192).
Construction de l’algorithme
Après un certain nombre de pas, on dispose d’un sous vecteur V( inf…sup) tel que
V(1 … inf – 1) < elem < V(sup +1….n)
1 inf m sup n

<elem ? ? ? ? ? >elem
on a deux cas :
- inf > sup ( inf = sup + 1 ) et comme V( 1… inf – 1 ) < elem < V( sup + 1 …. n )
alors inf =sup+1  elem V et l’algorithme est terminé.
- inf  sup, on exécute l’action : m ( inf + sup ) div 2
Et ( V( inf … m –1)  V( m )  V( m+1 … sup) est examiné. Ensuite on a trois
possibilités :
- elem = v( m ), l’algorithme terminé, elem  V.
- elem < V( m ), on doit poursuivre la recherche dans V( inf … m – 1 ) ; on exécute
alors l’action sup  m – 1 ; qui préserve l’assertion : elem < V( sup +1 … n)
- elem > V( m ), on doit poursuivre la recherche dans V( m+1… sup ) ; on exécute
alors l’action infm + 1 ; qui préserve l’assertion : V( 1… inf – 1 ) < elem.
L’assertion V( 1…inf – 1 ) < elem < V( sup +1 …n ) est donc bien préservée dans tous
les cas où l’on continue.
Initialisation : l’exécution des actions inf1 ; supn ; permet à V(1… inf – 1) < elem <
V( sup + 1 … n ) d’être un invariant.
Pour écrire l’itération, nous emploierons une variable booléenne « trouvé » initialisée à
« faux », qui deviendra « vrai » dès que nous aurons trouvé m tel que V( m ) = elem.
En résumé, le raisonnement est le suivant :
Hypothèse : V( 1…inf – 1 ) < elem < V( sup +1…n), non trouvé.
O n a deux cas :
- inf = sup +1  elem V  résultat = faux et l’algorithme est terminé.
- Inf  sup, on exécute l’action : m( inf + sup ) div 2 et trois possibilités peuvent
se présenter :
- V( m ) = elem  elem  V, trouvé  vrai  résultat  vrai et l’algorithme est
terminé.
- V( m ) > elem  sup  m – 1 ;  hypothèse ;
- V( m ) < elem  inf  m + 1 ;  hypothèse.
Itération : tant que ( inf sup ) et non trouvé faire …
Initialisation : inf  1 ; sup  n ; trouvé faux,  Hypothèse.
L’algorithme est le suivant :
Page 12
Fonction dicho(E V : vect ; E elem :t ) : booléen
Var inf, sup, m :entier ; trouvé  faux ;
Début
Inf 1 ; sup n ; trouvé faux ;
Tant que ( inf sup) et non trouvé faire
m ( inf + sup ) div 2 ;
si V( m ) = elem alors
trouvé  vrai
sinon si V( m ) < elem alors
inf m + 1
sinon sup  m – 1
fsi
fsi
fin tant que ;
dicho trouvé ;
finfonction ;
On peut également accélérer l’exécution de cet algorithme en ajoutant un test initial pour
savoir si elem est bien compris entre les deux éléments extrêmes du vecteur ; d’où :
Fonction dichobis( E V : vect ; E elem : t) : booléen ;
Var inf, sup, m :entier, trouvé : booléen ;
Début
Trouve :  faux;
Si ( elemV( 1 )) et (elem  V( n ))
Alors
Inf 1 ;
Sup n ;
Tant que( inf <= sup) et non(trouve) faire
M ( inf + sup )div 2 ;
Si V( m) = elem
Alors trouve  vrai
Sinon si V( m)< elem
Alors inf  m+1 ;
Sinon sup  m – 1 ;
Fsi ;
Fsi ;
Fin tant que ;
Fsi ;
Dichobis  trouvé;
Finfonction ;

Page 13
 1.3 Tri des vecteurs
Soit un vecteur V(1…n) à valeurs dans un ensemble E de valeurs muni d’une relation
d’ordre notée <.
Trier un vecteur V consiste à construire un vecteur V’(1…n) tel que
- V’(1…n) soit trié
- V’ et V contiennent les mêmes éléments.
Le plus souvent V et V’ sont le même vecteur. On construit V’ en permutant entre eux
des éléments de V.
1.3.2 Tri par remplacement
Il consiste à sélectionner des minimums successifs dans le vecteur d’origine et à les
ranger au fur et à mesure dans un nouveau vecteur que l’on construit.
1.3.2.1 Méthode : on veut construire un vecteur Vtrié(1…n) à partir de
v(1…n) tel que Vtrié(i – 1)  Vtrié(i), i [2..n].
Pour i = 2 , on a donc Vtrié(1)  Vtrié(2…n), Vtrié(1) est donc égal à :
minimum(V(1…n)). Il faut maintenant substituer dans V, à la valeur du minimum
trouvé, une valeur qui ne sera plus atteinte par la suite, lors de la recherche d’un nouveau
minimum. Il suffit de prendre comme valeur de remplacement un majorant de V(1…n)..
Nous prenons à titre d’exemple le maximum des éléments de V(1…n) ;
Hypothèse : Vtrié(1…i-1) est trié, Vtrié(1…i-1)  V(1…n), max=maximum(V(1…n)) ;
On a deux cas :
- i = n Vtrié(1..n) est trié, Vtrié(1…n-1)  V(1…n), il suffit donc d’exécuter
Vtrié(n)  max.
- i < n ; soit j tel que V(j) = minimum(V(1.n))  Vtrié(i)  V(j) ; V(j)  max ;
i  i+1 ;  hypothèse ;
itération : tant que i < n faire …
initialisation : i 1 ; max maximum(V(1…n)) ;  Hypothèse.
Il faut donc écrire un algorithme de tri qui utilise deux fonctions ; :
- une fonction qui retourne la place de l’élément minimum du vecteur V ;
- une fonction qui retourne la valeur du plus grand élément de V .
1.3.2.2 algorithmes
1.3.2.2.1 La fonction indice minimum.
Raisonnement par récurrence:
Hypothèse : j  [1…i – 1 ], V(j)  V(1…i – 1) ;
- i = n+1  j [1…n], V(j) V(1…n)  résultat = j ;
- in
- V(j) > V(i), j i ; i  i+1 ; Hypothèse
- V(j)  V(i) ; i  i+1 ; Hypothèse
Itération : tant que i  n faire
Initialisation : j 1 ; i 2 ; Hypothèse ; d’où la fonction :

Page 14
Fonction indmin(E V: vect) : entier ;
Var i, j :entier ;
Début
J 1 ; i  2 ;
Tant que i<= n faire
Si V(j) > V(i)
Alors j  i
Fsi
I  i +1 ;
Fin tant que
indminj ;
Fin fonction ;
1.3.2.2.2 La fonction maximum.
Le raisonnement par récurrence est très proche du précédent.
Hypothèse : max V(1…i-1), max  V(1…i-1) ;
- i= n+1  maxV(1…n), max  V(1…n)  résultat = max.
- in
V(i) > max  max  V(i) ; i  i +1 ; Hypothèse
V(i)  max i  i+1 ;  Hypothèse
Itération : tant que i  n faire …
Initialisation max V(1); i 2 ;  Hypothèse ; d’où la fonction :
Fonction maximum( E V: vect) :t ;
Var i : entier ; max : t ;
Début
Max V(1) ; i 2 ;
Tant que i n faire
Si V(i) > max
Alors max V(i)
Fsi
I i+1 ;
Fin tant que
Maximum max ;
Fin fonction ;

Page 15
 1.3.2.2.3 la procédure tri remplacement ;

procédure tri_remplacement( E V : vect ; S Vtrié : vect) ;

var max :t ; i,j : entier ;
Début
Maxmaximum(V(1…n)) ;
i 1 ;
Tant que i < n faire
j indmin(V( 1…n)) ;
Vtrie(i)  V(j);
V(j)  max
i i+1 ;
Fin tant que
Vtrié(n) max ;
Fin procédure ;
1.3.3 Tri par permutation
Il s’agit ici d’éviter la construction d’un second vecteur. V et vtrié sont confondus, ce
qui permet d’améliorer le coût dû à l’encombrement mémoire. On diminue aussi le
nombre d’accès au vecteur.
1.3.3.1 Méthode
Raisonnement par récurrence :
Supposons traités les i – 1 ( 1 i  n ) éléments du vecteur V.
On peut donc considérer le vecteur V comme la concaténation de deux sous vecteurs : le
sous vecteur V( 1…i – 1 ) dont les éléments ont été triés et le sous vecteur v( i…n )
dont les éléments n’ont pas été traités . D’autre part tous les éléments du sous vecteur
V( 1..i – 1 ) sont inférieurs ou égaux à tous les éléments du sous vecteur V(i…n ).
Hypothèse : V(1…i – 1 ) trié ; V(1…i – 1 )  V(i…n ) ; V( i…n ) non trié ;
- i = n V(n) non traité, V(1…n-1)  V(n) ; V(1…n-1) trié V(1…n) trié.
- I<n
Soit j tel que V(j) = minimum de V(i…n ) ; j [i…n]
j = i  i  i + 1 ; Hypothèse
ji permuter V(j) et V(i) ; i i+1 ; hypothèse ; d’où
- l’itération : tant que i <n faire…
- l’initialisation : i 1 ;  Hypothèse.
1.3.3.2 algorithmes :
- Nous allons chercher encore l’indice du minimum. Il s’agit presque du même
algorithme que pour le tri précédent. La seule différence est que l’indice de départ
est un paramètre i de la fonction au lieu de la constante 1.

Page 16
Fonction indmin(E V: vect) : entier ;
Var k, j : entier ;
Début
Ji ; k i+1
Tant que k  n faire
Si V(j) > V(k)
Alors j  k
Fsi
K k+1 ;
Fintant que
Indmin j ;
Fin fonction ;
1.3.3.2.1 procédure permutation :
procédure permut( E/S a,b : t) ;
var aux : t ;
Début
Aux a ; a b ; b aux ;
Fproc ;
1.3.3.2.2 procédure tri permutation :
procédure tripermutation( E/S V: vect) ;
var i, j :entier ;
Début
I1 ;
Tant que i < n faire
J indmin( V( i…n )) ;
Si j> i
Alors permut( V( i ), V( j ))
Fsi
I i+1 ;
Fin tant que
Fin procédure ;

1.3.4 Tri par bulles.

Il s’agit à nouveau d’une méthode qui opère par permutation à l’intérieur du vecteur à
trier.
1.3.4.1 Méthode :
On utilise le même raisonnement que dans le tri par permutation.
Pour augmenter le sous vecteur V( 1…i – 1 ) d’un élément, il faut chercher le plus petit
élément contenu dans le sous vecteur V(i..n) et placer cet élément en position i.
Page 17
Nous allons cette fois, au lieu de la recherche du minimum suivie d’une permutation,
utiliser la méthode des bulles: on parcourt le sous vecteur V(i…n ) de droite à gauche et
chaque fois qu’il y a deux éléments consécutifs qui ne sont pas dans l’ordre, on les
permute. Cette opération permet d’obtenir en fin de parcours le plus petit élément de
V( i…n ) placé en position i.
Le raisonnement de cette étape se présente ainsi :
Hypothèse : V( j )  V(j…n ) ; V( i…j – 1 ) non traité
- J = i V( i )  V( i…n ).
- j>i
V( j – 1 )  V( j )  j  j - 1 ; Hypothèse
V( j – 1 ) > V( j )  permut( V(j – 1 ), V( j )) et j j – 1 ;Hypothèse. D’où
L’itération : tant que j > i faire ….
L’initialisation : j n ; Hypothèse.

1.3.4.2 Algorithmes
L’algorithme de remontée s’écrit :
J n ;
Tant que j > i faire
Si V( j – 1 ) > V( j )
Alors permut( V( j ), V( j – 1 ))
Fsi
J j – 1 ;
Fin tant que
Le raisonnement du tri complet sera alors :
Hypothèse : V(1…i – 1 ) trié, V( 1…i – 1 ) V( i…n ), V( i…n ) non traité ;
- I = n  V( 1…n – 1 ) trié, V( 1… n – 1 )  V(n)  V(1…n ) trié.
- i < n permutation (bulles) de telle sorte que le minimum de V(i… n) soit placé en
V(i ), puis i  i + 1 ;  hypothèse, d’où
l’itération tant que i < n faire…
l’initialisation : i1 ;
Hypothèse.
On peut donc écrire maintenant l’algorithme complet du tri par la méthode des bulles.

Page 18
Procédure tribulles( E/S V: vect) ;
Var i, j : entier ;
Début
I 1 ;
Tant que i < n faire
J n ;
Tant que j > i faire
Si V( j – 1) > V( j )
Alors permut( V( j- 1 ), V( j ))
Fsi
J j – 1 ;
Fin tant que
I i+1 ;
Fin tant que
Fin procédure
1.4 Algorithmes de mise à jour d’un vecteur
Nous nous limitons la plus part du temps à des algorithmes d’insertion et de suppression
d’un seul élément dans un vecteur. Et nous supposerons que l’insertion est toujours
possible d’un point de vue physique, c’est à dire qu’il y a assez de places dans le vecteur
pour ajouter un élément (n< nmax).
1.4.2 Insertion d’un élément dans un vecteur non trié.
S’il n’y a aucun critère d’insertion, il suffit d’ajouter le nouvel élément à la fin du
vecteur et de ne pas oublier de mettre à jour le nombre d’éléments du vecteur.
Procédure inserfin ( E/S V :vect ; E elem :t) ;
Début
nn+1 ;
V( n ) elem ;
Finporcédure ;
Si au contraire, on veut ajouter un élément à la k ième place, ou après ( ou avant )
l’occurrence d’une valeur, alors les algorithmes sont de même type que celui de
l’insertion d’une valeur dans un vecteur trié que nous présentons ci-dessous.
1.4.3 Insertion d’un élément dans un vecteur trié.
Il s’agit d’ajouter au vecteur trié Vtrié ( 1…n), l’élément elem pour obtenir un nouveau
vecteur trié Vtrié(1…n+1) contenant tous les éléments de Vtrié(1…n) plus l’élément
elem.
Nous proposons ici une méthode qui consiste à :
- chercher la place de l’élément à insérer
- effectuer l’insertion de cet élément.
L’algorithme d’insertion sera donc le suivant :

Page 19
Procédure insertion(E/S Vtrié:vect ; E elem : t) ;
Var p : entier ;
Début
Si n = 0
Alors
Vtrié(1)  elem ;
n 1
Sinon
p posit(Vtrié(1…n), elem) ;
Inserplace( Vtrié(1…n), elem, p) ;
Fsi ;
Finprocédure ;
Où posit est une fonction qui délivre la place de l’élément elem et inserplace une
procédure d’insertion de elem à la place p.
1.4.3.1 Recherche de la place de l’élément à insérer.
On cherche un indice p [1…n+1] tel que la relation suivante soit vérifiée :
Vtrié(1…p-1)  elem <Vtrié(p…n).
En effet, on cherche une place le plus « à droite possible » afin d’avoir à effectuer le
moins possible de décalages pour l’insertion.
On remarquera que pour p=1, la relation se réduit à elem <Vtrié(1…n) et que pour p=
n+1 elle se réduit à Vtrié(1…n) elem.
Cette recherche peut être effectuée par une méthode séquentielle ou par une méthode
dichotomique. Nous proposons la méthode séquentielle.
On commence par chercher si p=1 ; sinon il reste à chercher p dans l’intervalle [2…n].
Pour cela, on effectue un parcours de droite à gauche :
Hypothèse Vtrié(1) elem <Vtrié(i…n+1)
- Vtrié(1)  elem  p  i+1.
- Vtrié(i) > elem i i-1 ; Hypothèse
Itération : tant que Vtrié( i ) > elem faire …
Initialisation
- Vtrié(1) > elem  p 1 .
- Vtrié(1) elem  i n  Hypothèse
L’algorithme est alors le suivant :

Page 20
Fonction posit (E Vtrié :vect ; elem : t) : entier ;
Var p, i : entier ;
Début
Si Vtrié(1) > elem
Alors p 1
Sinon
i n ;
tant que Vtrié(i) > elem faire
ii – 1
fintant que
pi+1
fsi
positp ;
finfonction ;
1.4.3.2 Insertion de l’élément à sa place.
On connaît maintenant la place p de l’élément à insérer. Le nouveau vecteur
Vtrié(1…n+1) est égal à la concaténation de trois sous vecteurs, que nous noterons :
Vtrié( 1…p-1) elem Vtrié(p+1..n+1) où Vtrié(p+1…n+1) est identique à
Vtrié(p…n).
Il suffit donc d’effectuer une translation à droite d’une position des éléments de
Vtrié(p…n) et ensuite d’affecter elem à Vtrié(p).
Procédure inserplace( E/S Vtrié : vect ; E elem : t ; E p :entier) ;
Début
Pour i = n à p faire
Vtrié(i+1)  Vtrié(i)
Finpour
N n+1 ;
Vtrié(p) elem
Finprocédure ;
1.4.4 Suppression d’un élément dans un vecteur.
Le problème est analogue à celui de l’insertion d’une nouvelle valeur. Toute fois, la
valeur n’appartient pas obligatoirement au vecteur V(1…n), dans ce cas la suppression
est impossible. On définira une variable booléenne « possible » permettant de savoir si
la suppression a été possible ou non. Nous nous intéressons à la suppression d’un
élément dans un vecteur trié. Pour la recherche d’une occurrence, on adoptera la
convention suivante : on cherche l’indice p (le plus grand possible) tel que p [1…n],
Vtrié(p) = elem. Si la valeur elem est inexistante on donne par convention à la variable p
la valeur zéro.

Page 21
Procédure suppr(E/S Vtrié(1…n) :vect ; E elem : t ; S possible : booléen) ;
Var p : entier ;
Début
Possible  faux ;
P posit(Vtrié(1…n), elem) ;
Si p > 0
Alors
Tasser( Vtrié(1…n), p) ;
Possible vrai ;
Fsi
Finprocédure ;
1.4.4.1 Recherche de la place de l’élément.
On cherche un indice p tel que : d’une part p [0…n] et d’autre part elem Vtrié[1…n],
p =0 ou bien Vtrié(p) = elem, elem < Vtrié(p+1…n), p [1…n].
Comme l’élément elem n’appartient pas obligatoirement au vecteur Vtrié(1…n), on
cherche d’abord p tel que vtrié(1…p) elem < vtrié(p+1…n), ensuite, il suffit de vérifier
si Vtrié(p)=elem pour conclure que l’élément est présent ou non ÿÿns lÿÿvecteur. On est
doÿÿ ramené à un algorithme semblable au précédent que l’on peut écrire avec une
méthode séquentielle ou dichotomique. Avec la méthode séquentielle, on effectue un
parcours de droite à gauche.
Raisonnement par récurrence
Hypothèse : Vtrié(1)  elem <Vtrié(i+1…n)
- Vtrié(1) > elem p=0 .
- Vtrié(i) = elem p = i.
- Vtrié(i) > elem  i =i – 1 ; Hypothèse. D’où
L’itération tant que Vtrié(i) > elem faire…
L’initialisation : Vtrié(1) > elem p 0 ; Vtrié(1) elem i n ; Hypothèse.
L’algorithme est alors le suivant :
Fonction positsup(E Vtrié(1…n) :vect ;E elem : t) : entier ;
Var p, i : entier ;
Début
P 0 ;
Si Vtrié(1)  elem
Alors
I n ;
Tant que Vtrié(i) > elem faire
I i- 1 ;
Fintant que
Si Vtrié(i) = elem
Alors p i

Page 22
 Fsi
Fsi
Positsup p ;
Finfonction ;
1.4.4.2 Écriture de la procédure tasser
Pour supprimer un élément d’indice p, il suffit de retasser tous les éléments ayant un
indice supérieur à p, cela revient à considérer que le nouveau vecteur Vtrié est la
concaténation de Vtrié(1…p – 1) et Vtrié(p+1…n).
Procédure tasser( E/S vtrié(1…n) :vect ; E p :entier) ;
Var j : entier
Début
Pour j = p +1 à n faire
Vtrié( j – 1 )  Vtrié(j) ;
Fin pour
nn – 1 ;
Finprocédure ;
On remarquera que la translation ou le décalage à gauche se fait à partir du premier
élément à gauche. Si le décalage était effectué à partir de la droite, toutes les valeurs de
Vtrié(p…n –1)seraient identiques à Vtrié(n).
T.D.1
1) Écrire une procédure qui affiche les éléments d’un vecteur dans l’ordre decroissant
des indices.
2) Écrire une fonction qui calcule le maximum des éléments d’un vecteur V(1…n).
3) Écrire une fonction qui calcule le nombre d’occurrences de la valeur « val » daans un
vecteur V(1…n).
4) On appelle bigramme une suite de deux lettres. Écrire une fonction qui calcule le
nombre d’occurrences d’un bigramme donné dans un vecteur de caracyères.
5) Écrire une fonction qui calcule le produit des éléments d’un vecteur V(1…n)
d’entiers
( penser au cas où un élément sera nul).
6) Écrire plusieurs manières différentes une fonction entière qui délivre l’indice de la
valeur « val » dans V(1…n) si « val » appartient au vecteur V(1…n) et 0 si « val »
n’appartient pas à V(1…n). Préciser dans chaque cas, si c ‘est la première ou la
dernière occurrence que l’on a trouvée.
7) Écrire une fonction entière qui retourne la place de la première occurrence de la
valeur « val » dans un vecteur trié Vtrié(1…n) si « val » appartient à Vtrié(1…n) et 0
dans le cas contraire.
8) Écrire une fonction de recherche qui délivre la place d’un élément « elem » dans le
vecteur Vtrié(1…n) par la méthode dichotomique. Cette fonction délivrera la place
de « elem » s’il y figure et 0 s’il n’y figure pas. ( On supposera que « elem » ne

Page 23
 figure pas plus d’une fois dans Vtrié(1…n), on dira que le vecteur est trié sans
répétition).
9) Écrire une fonction entière qui retourne la dernière occurrence de la valeur « val »
dans le vecteur trié Vtrié(1…n) si « val » appartient à Vtrié(1…n) et 0 dans le cas
contraire.
10) Modifier les tri remplacement, permutation et bulles pour qu’ils trient les
éléments de V(1…n) dans l’ordre décroissant ( deux solutions différentes pour
chaque méthode de tri).

Page 24
 1.5 TABLEAUX
1.5.1 Objectif
Il s’agit de réunir dans un même objet, des éléments de même nature pour alléger la
description de l’algorithme.
Pour cela faut-il enrichir le vocabulaire algorithmique par un nouveau type adéquat
correspondant à une collection d’objet de même type et pouvant subir les mêmes
traitements.
Cette opération revient à :
- réserver plusieurs objets de même nature par une seule déclaration ;
- les identifier par un nom commun : « nom du tableau » et par un indice séquentiel :
« indice »
- les manipuler en spécifiant le nom du tableau et l’indice.
1.5.2 Syntaxe
Type nomtableau = tableau ( interv ) de typelt ;
Où nomtableau est le nom du tableau ; interv : un intervalle ; typelt : type commun à
tous les éléments du tableau.
Chaque élément sera désigné d’une manière non ambiguë par le nom du tableau
auquel il appartient et par une position appelée indice : nom-tab(indice) ; où nom-
tab est le nom du tableau ; indice est une valeur qui, une fois évaluée doit être
comprise dans l‘intervalle de son type de définition.
L’affectation peut être réalisée globalement entre deux tableaux de même type. Les
opérations de saisie et d’affichage sur les tableaux sont définis au niveau d’un élément.
Remarques :
1. Il faut utiliser des tableaux chaque fois qu’il faut manipuler plusieurs objets de même
type.
2. Les opérations sur un tableau T comme la lecture ou l’écriture sont définies au niveau
élémentaire. Ainsi peut-on dire Afficher ( T(i)) sous reserve de connaître la valeur de i.
3. Lorsque l’on utilise T(i), il faut toujours vérifier que i est dans l’intervalle de
définition du tableau. L’erreur correspondante est appelée « débordement du tableau »
4. La boucle « Pour…FinPour » permet de parcourir exactement une fois tous les
éléments du tableau en gérant automatiquement l’indice de contrôle.
1.5.3 Sémantique
On appelle tableau, toute collection d’objets de même type. Ces objets sont regroupés
sous le même nom et peuvent être désignés par un indice relatif à cette collection.
Si interv est un intervalle d’entiers délimité par inf et sup, le nombre d’éléments du
tableau est : sup – inf +1.
1.5.4 Tableau à une dimension
1.5.4.1 Tableau de constantes
Comme pour les constantes élémentaires, il est possible d’utiliser des constantes de type
tableau. Elles seront soumises à la même contrainte d’invariabilité du contenu.
Syntaxe est : Const nom-tab : typtab(v1,v2,….,vn) ; où vi est la valeur de la ième
constante
Page 25
 1.5.4.2 Tableau de variables
Comme pour les variable élémentaires, il est possible de donner des valeurs initiales à
chaque objet de la collection et cela, lors de la déclaration de l’objet de type tableau. Il
est bien entendu que toutes les valeurs peuvent être modifiées à volonté dans
l’algorithme. Il s’agit là d’un tableau initialisé de variables et non d’un tableau constant.
Syntaxe est :Var nom-tab : typtab(init(v1,v2,…,vn)) ; où nom-tab est le nom du
tableau vi : expression définie de type compatible à celui des éléments du tableau ;
typtab est la description du tableau dont les éléments sont tous de type typelt.
1.5.5 Les tableaux à plusieurs dimensions
1.5.5.1 Nécessité
On se propose de généraliser les notions abordées lors de la présentation des tableaux à
une dimension aux tableaux à deux puis à trois … dimensions.
Cette généralisation est indispensable car beaucoup de traitements vont nécessiter la
manipulation de tels tableaux.
Par exemple, on veut calculer la moyenne annuelle sur 5 notes pour 24 étudiants d’une
classe ainsi que les moyennes de classe par note.
A l’état actuel des connaissances on a le choix entre les solutions suivantes :
- soit avec 5 tableaux à une dimension de 24 notes,
- soit avec 24 tableaux à une dimension de 5 notes.
Les éléments des différents tableaux étant du même type, on est tenté de les regrouper
dans un même objet qui aurait le même rôle qu’une famille de classeur de notes gérée
par le service de scolarité.
1.5.5.2 Objectif
Il faut se donner les moyens algorithmiques pour déclarer et utiliser des tableaux à
plusieurs dimensions. Il s’agit de généraliser les notions précédentes. Pour cela il faut :
- identifier le nouvel objet par un nom ;
- donner le type commun des éléments ;
- associer un indice à chaque dimension.
Syntaxe
type typtab : tableau( int1 [, int2, int3, ….]) de typelt ;
où typtab est le nom du type de tableau ; int1, int2,… sont des intervalles ; typelt est le
type commun à tous les éléments du tableau.
1.5.5.3 Sémantique
Le type typtab est un nouveau type construit par le programmeur, il pourra l’utiliser par
la suite pour déclarer des objets de type typtab, c’est à dire des tableaux dont les
éléments sont tous du type typelt.
Pour accéder aux éléments d’un tableau à plusieurs dimensions, il faut associer un indice
à chaque dimension. Cet indice ne peut varier que sur son intervalle de définition.Toutes
les valeurs prises doivent être compatibles à ce type.
On écrit l’accès à un élément d’un tableau à plusieurs dimensions par nom-tab(i,j,k,…) ;
Où nom-tab est le nom du tableau.
- i est un élément dans l’intervalle int1, pointant sur le ième plan ;
Page 26
- j est un élément dans l’intervalle int2, pointant sur la jième ligne ;
- k est un élément dans l’intervalle int3, pointant sur la kième colonne et ainsi de suite
pour les indices suivants.
1.5.5.4 Tableaux de constantes
syntaxe Const nom-tab : typtab( liste) ;
les valeurs de la liste sont affectées aux éléments du tableau en partant du niveau le plus
global et en allant vers celui le plus bas.
Si par exemple, un tableau est composé de dix lignes et de 5 colonnes, les 5 premières
valeurs iront dans la première ligne, les 5 suivantes dans la deuxième ligne etc…
1.5.5.5 Tableaux de variables
Syntaxe var nom-tab : typtab[init(liste)] ;
L’affectation des valeurs aux éléments du tableau se fait comme pour un tableau
constant ; nom-tab est le nom du tableau ; liste est une suite de données organisées
par niveau.
Par exemple pour un tableau à 3 dimensions on a : liste-plan ; à deux dimensions,
liste-ligne. Où
Liste-plan = ( liste-ligne1, liste-ligne2, …., liste-lignep) ;
Liste-ligne = ( liste-val1, liste-val2, …., liste-valn ) ;
Liste-vali = ( v1, v2, …,vm) ; vi sont des expressions définies du type déclaré ;
P est le nombre de plans ; n le nombre de lignes ; m le nombre de colonnes.
Remarque : une erreur fréquente consiste à adresser un élément du tableau avec,
pour l’un des indices, une valeur qui sort du domaine de définition. Pour se
prémunir de ce risque, lorsque l’on veut parcourir tous les éléments d’un tableau, on
peut utiliser les boucles Pour …FinPour emboîtées.
T.D. 2
1. écrire un algorithme qui calcule la moyenne annuelle sur 5 notes pour 24
étudiants d’une classe ainsi que les moyennes de classe par note.
2. Ecrire un algorithme qui réalise l’initialisation des éléments de 3 tableaux de 10
entiers de la façon suivante :

0 0 0 0 0 0 0 0 0 0

1 2 3 4 5 6 7 8 9 10

20 18 16 14 12 10 8 6 4 2

3. écrire un algorithme qui réalise l’initialisation des éléments de 3 tableaux

suivants :

1 2 3 4 5
1 2 3 4 5

Page 27
 1 2 3 4 5
6 7 8 9 10
11 12 13 14 15

0 0 0 0 0
1 0 0 0 0
2 2 0 0 0
3 3 3 0 0
4 4 4 4 0

4. Occupation des salles d’un établissement scolaire.

Un tableau OCCUP à 3 dimensions décrit le plan d’occupation des salles d’un
lycée durant une semaine, un tableau CAPA à une dimension indique la capacité
maximale de chacune des salles.
Chaque élément OCCUP(i,j,k) est tel que :
- i : numéro d’ordre de la salle variant de 1 à 50
- j : numéro du jour ouvrable de la semaine variant de 1 à 6
- k : numéro de la tranche horaire de 1 heure, variant de 1 à 10.
Les valeurs prises par OCCUP(i,j,k) sont 0 ou 1 où 1 signifie : salle occupée ;
0 signifie : salle libre.
Exemple OCCUP(3,2,4)=1 signifie que la salle n° 3 est occupée le mardi à la
4ème tranche horaire de 11h30 à 12h30, pour une journée de 10 heures
commençant à 8h30.
Ecrire un algorithme qui indique, pour un jour donné ( jourlu) et une tranche
horaire donnée ( heurlu) ; toutes les salles d’une capacité supérieure ou égale à
un nombre donné capalu. Les valeurs saisies : jourlu, heurlu et capalu doivent
être contrôlées.

Page 28
2 Les fichiers :
2.1 Notions de fichier
Les objets que nous avons décrits jusqu’ici n’ont qu’une durée brève, leur existence est
limitée à la période d’exécution du programme dont ils constituent l’environnement.
Pourtant il y a de très nombreuses applications pour lesquelles les informations traitées
doivent être conservées bien au-delà de la durée d’exécution du programme de
traitement. Si non comment une banque par exemple pourrait-elle envisager sa gestion si
les informations relatives aux comptes de ses clients n’existaient plus après le traitement
de mise à jour de ces comptes ?
Très tôt en informatique est apparu le besoin de conserver des informations, en dehors
de la mémoire centrale de l’ordinateur sur un support permanent.
Par ailleurs, le volume de certaines données interdit de les représenter ensemble dans
l’espace disponible en mémoire centrale. On est alors conduit, pour le traitement de ces
données, à les fractionner en unités plus petites : un programme qui calcule la paye
d’une entreprise traite l’ensemble des informations relatives au personnel de l’entreprise,
mais, à un instant donné, n’a besoin que des données qui concernent l’employé dont il
prépare le bulletin de paye.
La notion de fichier est conçue pour répondre aux deux impératifs que nous venons
d’évoquer :
- Stockage permanent de l’information ;
- Rassemblement d’un gros volume d’informations pouvant être fractionnées
pour le traitement
Définitionun fichier est une collection d’informations, structurée en unités d’accès
appelées article ou enregistrement qui sont tous de même type, en général composé.
Par exemple le fichier des résultats à un examen comprendra un article par étudiant,
chaque article étant composé de 4 champs :
- Nomprenom de type chaine (30)
- Numinscrit de type entier ;
- Datenaissance de type tdate ;
- Note de typeréel ;
Un fichier est toujours enregistré sur un support externe à la mémoire centrale et tout
programme de traitement échangera des informations avec le fichier, l’unité d’accès
étant l’article : on lira le fichier article par article, on l’écrira article après article. A un
instant donné, les informations extraites du fichier par le programme sont celles d’un
article et non celles du fichier tout entier.
2.2 Supports séquentiels et supports adressables :
On distingue deux catégories de supports :
2.2.1 Les supports séquentiels, sur lesquels les informations sont écrites les unes à la
suite des autres et qui sont tels que l’accès àune information i nécessite le
passage sur toutes les informations qui précédenti sur le support ;

Page 29
2.2.2 Les supports adressablessont structurés en surfaces d’enregistrement
individuellement adressables : les informations qui y sont enregistrées peuvent être
retrouvées directement grâce à leur adresse, sans que l’on ait à passer par des
enregistrements intermédiaires.
La bande magnétique est un type classique de supportséquentiel : les enregistrements
sont disposés de manière consécutive sur le ruban magnétique et, pour retrouver un
enregistrement donné on devra faire défiler devant la tête de lecture, toute la partie du
ruban qui précède l’enregistrement.
Les disques sont les supports adressables les plus utilisés. Une unité de disques
comprend une ou plusieurs surfaces circulaires de lecture / écriture. Sur chaque surface,
les informations sont enregistrées sur des pistes concentriques. Les pistes sont souvent
divisées en secteurs et une adresse est, en général l’association d’un numéro de piste et
d’un numéro de secteur. Le dispositif de lecture / écriture peut se déplacer au dessus des
surfaces d’enregistrement pour accéder rapidement à une adresse donnée.
2.3 Organisation et accès :
2.3.1 Accès :Selon les impératifs du traitement, on utilise
deux techniques d’accès aux articles d’un fichier :
- avec l’accès séquentiel, on accède aux fichiers dans l’ordre d’enregistrement
des articles.
- Avec l’accès sélectif, on accède directement à un article particulier sans passer
par des articles intermédiaires. Cet accès n’est possible qu’avec des supports
adressables.
2.3.2 L’organisation d’un fichier, définit la manière dont les
articles du fichier sont disposés sur le support. On
distingue trois organisations principales :
- L’organisation séquentielle qui ne permet que l’accès séquentiel ;
- L’organisation directe conçue pour l’accès sélectif ;
- L’organisation séquentielle indexée qui permet l’accès séquentiel et l’accès
sélectif.
2.4 Association d’un fichier à un programme :
Un fichier f est identifié, de manière unique, par un nom externe qui lui est attaché. Il
peut exister plusieurs programmes de traitement de f et, dans l’environnement de chacun
d’eux, f est décrit avec un nom interne et qui n’a en général aucun rapport avec le nom
externe.
Au moment de traiter un fichier, un programme doit s’assurer le contrôle de ce fichier à
l’aide d’une primitive d’ouverture de fichier. Le rôle d’une telle action est :
- D’établir la correspondance entre le nom interne et le nom externe.
- D’assurer au programme le contrôle du fichier ;
- D’effectuer le positionnement initial du dispositif de lecture / écriture sur le
support de fichier.
Si f est le nom interne du fichier, nous noterons ouvrir (f) la primitive qui doitdébuter le
traitement de f.
Page 30
Enfin de traitement, le programme indiquera qu’il n’a plus besoin du fichier f en
effectuant la fermeture de f au moyen de primitive fermer (f). L’exécution d’une telle
primitive :
- complète le fichier par une marque de fin de fichier dans le cas où le traitement
était une création de fichier.
- Abandonne le contrôle du fichier en indiquant au processeur que le programme
n’a plus besoin du fichier et que ce dernier est donc disponible pour être traité
par d’autres programmes.
- L’exécution des primitives d’ouverture et de fermeture est en général
accompagnée par des commandes, extérieures aux programmes et
particulièrement au système d’exploitation utilisé qui précisent le nom externe
et la localisation du fichier.
Pour les fichiers que nous étudierons, tous les articles seront de même type.
Si f est le nom d’un fichier d’articles de type t et si dans l’environnement d’un
algorithme, v est une variable du même type t, nous noterons :
1) écrire (nom de fichier, v) ou écrire (f, v), l’action qui ajoute un nouvel article au
fichier f, en recopiant dans cet article la valeur de v.
2) lire (f, v), l’action primitive qui lit un article du fichier f, en affectant la valeur de
cet article à la variable v.

Variable
V Environnements
Ecrire (f, v)
////////////////// ------------------------------

Fichier lire (f, v) Actions

Disque ou disquette
Algorithme
2.5 Les fichiers séquentiels :
2.5.1 Définition : soient :
- un ensemble X quelconque dit « des valeurs » du fichier séquentiel
- un ensemble P fini, totalement ordonné, dit ’ensemble des places du fichier
séquentiel.
Un fichier séquentiel à valeurs dans X est une application f de P dans X.
Remarques :
a) un fichier peut être vide ;
b) dans les algorithmes décrits, nous supposons les valeurs de X quelconques.
c) Pour un fichier, toutes les valeurs sont de même type.
2.5.2 Notations

Page 31
Dans la suite, un fichier séquentiel, défini à partir des ensembles P et X est noté
fonctionnellement (P, f, X) ou simplement f.
Un fichier séquentiel est représenté pratiquement par la suite ordonnée de ses éléments,
notée : < x1, x2, x3, …., xn> (xiX)

Exemple : f = < ‘A’, ‘BCI’, ‘DEHK’, ‘D’> ; f = < x1, …, xi, xi+1, …., xn>où xi X
2.5.3 Sous fichiers :
a) Définition : soit un fichier (P, f, X). nous appelons sous fichier la restriction
de f à un intervalle de P (suite d’éléments consécutifs)

Exemple : si f = <5, 7, 59, 67, -1, 0, 18, > alors < 5, 7, 59 >, < 67, -1, 0, 18> sont des
sous fichiers de f. par contre, < 5, 59, 18> n’est pas un sous fichier.

a) Notation : on note un sous fichier d’un fichier (P, f, X), fi j si fi j est la restriction de f
à l’intervalle [i….j]. On note un sous fichier par la suite ordonnée de ses éléments : fij
= < xi … xj>
b) Remarques:
Fi+ 1i est un fichier vide, de même fij est vide si i > j
Le fichier fconsidère comme un sous fichier est note f1n
Tout fichier vide sera note <>
2.5.4 Concaténation de deux fichiers :
Cette opération est une loi de composition interne définie sur l’ensemble des fichiers
à valeurs dans un ensemble X.
Si f1 = < x1, x2, x3, …., xn> ; f2 = < y1, y2, y3, …., ym> xi , yj  X alors f = f1 f2
est égal à : f = < x1, x2, x3, …., xn, y1, y2, y3, …., ym>
Ainsi peut-on décomposer tout fichier f en k sous-fichiers f1, f2, ….., fk tels
que : f = f1 f2….. fk
Si f comporte n éléments, lesfi sont vides pour i > n. Cette opération de concaténation
est associative mais n’est pas commutative.
2.5.5 Somme d’un fichier et d’une valeur :
Soit un fichier f à valeurs dans X et une valeur val  X, on appelle somme du fichier
f et de la valeur val que l’on note (f val), le fichier g défini par
g = f’ « val » 
f’’ avec f = f’f’ .
Exemple : soient f = < 5, 10, 3, 9 > et val = 12 ; le fichier g = f val peut être égal
à :< 5, 10, 3, 12, 9 > ou < 5, 12, 10, 3, 9 > ou < 12, 5, 10, 3, 9 > ou ………………

2.5.6 Somme de deux fichiers :

On appelle somme de deux fichiers f et g = < y1, y2, y3, …., ym> à valeur dans un même
ensemble X, le fichier h défini par : h = f y1 y2……. yn

Page 32
 2.5.7 Autres Notations :
Soient un fichier f (f = < x1, x2, x3, …., xn> ) à valeurs dans un ensemble ordonné X (xi
X) et une valeur a X, on définit les notations suivantes :
a < f signifie que  i  [1…n], a < xi
- af signifie que i [1…n], a = xi
- a f signifie que i [1…n], a ≠ xi
- a=f signifie que i  [1…n], a = xi
- a≠f signifie que i  [1…n], a ≠ xi

On peut de même définir les notations : a ≤ f, a > f, a ≥ f

2.5.8 Accès à un élément d’un fichier :

La définition ensembliste d’un fichier n’est pas suffisante pour son traitement en
informatique, car nous disposons du graphe fini d’une application (ensemble fini
d’exemplaires de valeurs) mais suivant la manière dont on va pouvoir accéder à chacun
de ses éléments, les caractéristiques algorithmiques de l’ensemble fini vont différer. Ce
sont pratiquement ces accès qui vont caractériser la structure d’information : fichier.
Pour un fichier ces accès vont être définis en tenant compte du fait que l’ensemble P est
totalement ordonné et fini.
2.5.9 Actions primitives d’accès :
Pour donner un modèle du comportement dynamique d’un fichier, nous allons définir
des actions élémentaires dites « primitives d’accès » à la valeur de chaque élément.
2.5.9.1 Interpréteur associé à un fichier séquentiel :
Nous supposons que tout fichier peut être schématisé par un ruban défilant devant une
tête de lecture/écriture. On n’a accès à une valeur que lorsque l’élément correspondant
(appelé élément accessible ou élément courant) est en face de la tête de lecture-écriture.
Un fichier étant une suite finie, on introduit une marque sur le ruban (notée ┤) qui
permet au mécanisme d’interprétation de détecter la fin du fichier. Un fichier n’est défini
que s’il comporte une marque.

Tête de lecture Sens du défilement

X1 X2 X3 X4 ................. Xn f

L’élément courant (X 3 sur l’exemple) permet, par définition de decomposer un fichier

en deux sous-fichiers remarquables : f = f -  f + ou f – est le sous fichier déjà « lu » et
f+ est le sous fichier qui reste à lire. L’élément courant est le premier élément de f +.
Dans l’exemple précédent on a : f - = < X1, X2> et f + = <X3 , ….., Xn> , élément courant
= X3
Page 33
Pour toutes les primitives d’accès, nous donnons la forme d’appel et la spécification qui
en décrit la sémantique.
2.5.9.2 Prédicat fin de fichier fdf (nom fichier) :
Ce prédicat (fonction booléenne) noté fdf prend la valeur vrai si on a atteint la marque
de fin de fichier ; il prend la valeur faux dans le cas contraire. C’est l’exécution des
primitives définies ci-après (relire, lire, réécrire, écrire) qui permet de donner une valeur
au prédicat fdf. L’entête est le suivant :
Fonction fdf ( E/S f : fichier de t) : booléen ;
Spécification {} {résultat = (f + = <>)}
2.5.9.3 Primitives d’accès au premier élément : Relire (nom fichier) ;
Cette action rend possible l’accès au 1er élément du fichier s’il existe. Elle positionne le
ruban de telle sorte que la tête de lecture/écriture soit en face du 1er élément du fichier
pour en permettre la lecture. D’autre part afin de permettre la détection de la fin d’un
fichier le prédicat noté fdf (nom de fichier) prend la valeur « vrai » si la tête de
lecture/écriture est positionnée en face de la marque de fin de fichier, « faux » dans le
cas contraire.
Dans le cas d’un fichier non vide, la primitive relire donne la valeur faux au prédicat fdf.
Dans le cas d’un fichier vide, le prédicat fdf prend la valeur « vrai ». On peut
schématiser l’action relire par :
Tête de lecture
fdf(f) Sens du défilement

X1 X2 X3 X4 ................. Xn f

f+

f – est vide, X1 est l’élément courant donc accessible et fdf (f) prend la valeur faux (on
écrit :
fdf (f) ).
Dans le cas du fichier vide :
Tête de lecture

fdf (f)

f
fdf (f) prend la valeur vrai (on écrit : fdf (f) ).
L’entête est le suivant :
Procédure relire (E/S f : fichier de t) ;
Spécification {} {fdf (f), f - = <>, f + = f, f ≠ <>) ou
(fdf (f), f - = <>, f + = <>)}

Page 34
 2.5.9.4 Primitive d’accès à l’élément courant : lire (nom fichier, val)
Cette primitive permet d’accéder à la valeur de l’élément courant et de sélectionner
l’élément suivant. Elle réalise dans l’ordre :
- La copie de l’élément courant (lecture) pour la mettre dans val
- L’avancement du ruban d’une position. Si la marque de fin de fichier est
sélectionnée alors fdf (nom-fic) prend la valeur vrai sinon fdf (nom-fic)
conserve la valeur faux.
Cette primitive ne peut pas être utilisée si le prédicat fdf a la valeur vrai avant
l’activation de l’action lire
L’entête est le suivant :
Procédure lire (E/S f : fichier de t ; E val : t) ;
Spécification {f - = f1i-1 ; f + = fin ; fdf (f)}{val= xi, f -= f1i ; f + = fi+ 1n (fdf (f),
f + ≠ <>) ou (fdf (f), f + = <>)}
On constate qu’après l’appel de l’action lire, val = Df – où Df – désigne le dernier
élément du fichier f - . On peut schématiser l’action lire par :

Avant :
Tête de lecture
fdf (f) Sens du défilement

X1 X2 ….. Xi ................. Xn

Après Sens du défilement

┐
fdf (f) X1 X2 ….. Xi Xi+1 . . . . . . . . . . . . . . . Xn

Xi Val
f - f+

Ou Avant Sens du défilement

┐
fdf (f) X1 X2 ….. Xi Xi+1 . . . . . . . . . . . . . . . Xn
f- f+
+

Après Sens du défilement

fdf (f) X1 X2 ….. Xi Xi+1 . . . . . . . . . . . . . . . Xn

Xn Val
f-
< f + vide>

Page 35
Notation f - -
–- –
On utilisera aussi la notation f - -définie par f - = f - -  val. f est donc le fichier f
avant l’exécution de l’action lire (f, val).
Exemple de lecture d’un fichier avec f=<24,-10,53>

Actions exécutées f-- f- f+ val fdf(f)

initialement indéfini indéfini
Relire(f) <> <24,-10,53> indéfini faux
Lire(f,val) <> <24> <-10,53> 24 faux
Lire(f,va) <24> <24,-10> <53> -10 faux
Lire(f,val) <24,-10> <24,-10,53> <> 53 vrai
Lire(f,val) impossible
Remarques : dans un ordinateur, tout fichier est identifié :
- Au niveau du système d’exploitation (exemple : Unix, Ms-Dos) par un nom
physique, qui est une chaine de caractères ;
- Au niveau du langage de programmation (exemple : pascal, ada) par un
identificateur, comme tout autre variable. Le type de cet identificateur sera
défini comme : fichier de t où t est le type des éléments du fichier (exemple :
fichier de caractères, fichier de personne, ..).
L’association de l’identificateur à un fichier physique de nom externe donné se
fait le plus souvent à l’ouverture par des primitives telles que relire et réécrire
données ci-dessus. Mais en spécifiant l’identificateur ainsi que le nom externe.
Exemples : reset (f, ‘fdonnée.dat’) ou rewrite (f, ‘resultats’).dans certaines
implémentations de pascal .Open (f, infile, "fdonnées.dat’’) ou create (f,
‘‘résultats’’) en ada. D’autres langages séparent l’association de l’ouverture au
moyen d’une instruction spécifique d’association
2.5.9.5 Primitive de création d’un fichier vide : Reécrire (nom de fichier)
Cette primitive a pour objet de créer un nouveau fichier vide ayant pour nom « nom de
fichier ». le prédicat fdf (nom de fichier) prend la valeur vrai.
L’entête est le suivant :
Procédure réécrire (E/S f = fichier de t) ;
Spécification {} { f = <> , fdf (f)}

Attention : si le fichier contenait au préalable des informations celui-ci deviendrait vide

et toutes les informations seraient perdues.
2.5.9.6 Primitive d’ajout d’un élément : écrire (nom fichier, val) ;
On ne peut utiliser cette primitive que si la tête de lecture/écriture est positionnée en fin
de fichier (c'est-à-dire si le prédicat fdf (nom de fichier) a la valeur vrai).
L’interprétation de cette primitive est la suivante : on effectue dans l’ordre :
- Recopie, en fin de fichier, de la valeur contenue dans val ;

Page 36
 - Avancement du ruban d’une position, afin de positionner la tête de lecture /
écriture sur la marque de fin de fichier ;
Après exécution, le prédicat fdf a toujours la valeur vrai. On peut schématiser cette
primitive par :
Avant Sens du défilement Xn Val
-1-
fdf (f) X1 X2 ….. Xi Xi+1 . . . . . . . . . . . . . . . 1- Xn-1

Après Sens du défilement Xn Val

fdf (f) X1 X2 ….. Xi Xi+1 . . . . . . . . . . . . . . . Xn-1 Xn

L’entête de la procédure est :

Procédure(E/S f : fichier de t ;E val :t) ;
Spécification { f=x1,x2,….,xi-1>, val =xi, fdf(f) } { f=< x1 x2 …. , xi>, val = xi, fdf(f)}
On notera qu’après exécution de la primitive écrire(f,val), fdf(f) a toujours la valeur
« vrai ».
Exemple de construction d’un fichier f.

Actions exécutées Val f

Reécrire(f) indéfini <>
Val :=5 ; écrire(f,val) 5 <5>
Val :=8 ; écrire(f,val) 8 <5,8>
Écrire(f,val) 8 <5,8,8>
Écrire(f,18) 18 <5,8,8,18>

2.5.10 Algorithmes traitant un seul fichier :

Somme des éléments d’un fichier f non vide de nombres entiers :
Recherche de la valeur maximale contenue dans un fichier :
Soit un fichier f non vide, tel que l’ensemble des valeurs soit muni d’une relation d’ordre
total notée < sur N. Le problème consiste à trouver une valeur m Є f et telle que y Є f,
on ait m ≥ y. une telle valeur est dite maximale.
L’algorithme est le suivant :

Page 37
 Procédure maximum (E f : fichier de t ; S maxi :t) ;
Var max, c : t ;
Debut
Relire(f) ;
Lire (f, max) ;
Tant que ┐fdf (f) faire
Lire(f,c) ;
Si max < c
Alors max  c
Fsi ;
Ftq ;
Maxi  max ;
Fproc ;
On peut également écrire cet algorithme sous forme de fonction :
Fonction maxi (E f : fic de t) : t ;
Var max, c : t ;
Debut
Relire(f) ;
Lire (f, max) ;
Tant que ┐fdf (f) faire
Lire(f,c) ;
Si max < c
Alors max  c
Fsi ;
Ftq ;
Maxi  max ;
Ffonc ;
2.5.10.1 Accès à un élément d’un fichier :
Ce problème fondamental est formulé habituellement de deux manières :
 Soit on connaît le rang k de l’élément que l’on cherche dans le fichier et on
cherche alors le kième élément du fichier ;
 Soit on ne connaît pas ce rang, mais on connaît la valeur de l’élément que l’on
cherche et l’on cherche le 1er élément qui correspond à cette valeur (c'est-à-dire la
première occurrence).
On parle alors de recherche ou d’accès :
 Par position dans le 1er cas
 Par valeur ou associatif dans le second cas

Page 38
 2.5.10.1.1 Accès par position (accès au kième élément) :

Procedure accesk (E/S f : fic de t ; E k :entier ; S : valk : t ; S : trouve : :

booléen) ;
Var c : t ; i : entier ;
Debut Debut
Relire(f) ; Relire (f) ;
Trouve  faux ; Trouve  faux ;
i1; i1;
┐ ┐
tant que (i<k) et fdf (f) faire tant que (i ≤ k) et fdf (f) faire
lire (f, c) ; lire (f, c) ;
i i + 1 ; i i + 1 ;
ftq ; ftq ;
┐
si fdf (f) si i =k +1
Ou encore
alors alors
trouve vrai ; trouve vrai ;
lire (f, valk) ; valk c ;
fsi ; fsi ;
fproc ; fin ;

2.5.10.1.2 Accès à un élément par valeur dans un fichier Ordonné (fichier trié) :
2.5.10.1.2.1 Définition :
Supposons que l’ensemble des valeurs d’un fichier soit muni d’une relation d’ordre
définie comme précédemment. Si tous les éléments consécutifs d’un fichier vérifient la
relation d’ordre (Xi ≤ Xi+1), on dit que le fichier est trié par ordre croissant. Dans la
suite, sauf avis contraire, on appellera fichier trié (ou ordonné) un fichier ordonné par
ordre croissant. On admettra que le fichier vide et le fichier ne contenant qu’un seul
élément sont triés.
En d’autres termes on donne la définition du fichier trié :
Fichier trié :
 Un fichier vide est trié ;
 Un fichier comportant un seul élément est trié ;
 Soit un fichier f = < x1, x2, …., xn>, avec n > 1, le fichier f est trié si  i Є [1..n-
1], la relation (Xi ≤ Xi+1) est vraie.
2.5.10.1.2.2 Algorithme vérifiant qu’un fichier est trié :

Page 39
 Fonction trié (E f : fic de t) :booléen ;
var c, precedent : t ; est_trie :booléen ;
Debut
relire (f) ;
si fdf (f)
alors
est_trie vrai
sinon
lire (f, precedent)
si fdf (f)
alors
est_trie vrai
sinon
lire (f, c) ;
tant que ( ┐fdf (f)) et ( precedent ≤ c ) faire
precedent c ;
lire (f, c) ;
ftq ;
est_trie (precedent ≤ c) ;
fsi ;
fsi ;
trie est_trie ;
Ffonc ;
Ou encore :
fonction trié (E f : fic de t) :booléen ;
var c, precedent : t ; est_trie :booléen ;
Debut
relire (f) ;
si fdf (f)
alors
est_trie vrai
sinon
lire (f, precedent) ;
c precedent ;
tant que ( ┐fdf (f)) et ( precedent ≤ c ) faire
precedent c ;
lire (f, c) ;
ftq ;
est_trie (precedent ≤ c) ;
fsi ;
trie est_trie ;
ffonc ;
Page 40
 2.5.10.1.2.3 Algorithme d’accès à un élément dans un fichier trié :
Dans le cas d’un accès associatif, la relation d’ordre définie sur l’ensemble des valeurs
permet d’éviter un parcours complet des éléments du fichier pour conclure à la non
appartenance d’un élément. En général, l’accès associatif dans un fichier ordonné est
plus rapide que dans le cas d’un fichier non ordonné. On s’efforce, dans la pratique,
d’utiliser, chaque fois que cela est possible, un fichier trié.

Fonction accèst (E f : fic de t ; E val : t) : booléen ;

Var c : t ; present : booléen ;
Debut
relire (f) ;
si fdf (f)
alors
present faux
sinon
lire (f, c) ;
tant que ( ┐fdf (f)) et ( c< val ) faire
lire (f, c) ;
ftq ;
si c = val
alors present  vrai
sinon pressent  faux
fsi ;
fsi ;
accest present ;
ffonc ;

2.5.11 Algorithmes traitant plusieurs fichiers

Ces algorithmes prennent des éléments sur un ou plusieurs fichiers et construisent un ou
plusieurs autres fichiers. Ils ont de nombreuses applications en gestion et programmation
système. Tous ses algorithmes sont construits à partir du parcours des éléments d’un ou
plusieurs fichiers (ils se terminent puisque le nombre d’éléments est fini). On a
l’habitude d’appeler ce fichier (ou ces fichiers) privilégié(s), fichier (s) pilote (s) ou
directeur(s). Tous ces algorithmes s’expriment par une séquence d’actions itératives.
2.5.11.1 Algorithme de création par copie d’un fichier existant :
Ce problème consiste à créer à partir d’un fichier f =< x1, x2, …., xn>, un fichier
identique g = < x1, x2, …., xn>. L’algorithme est très simple. Il suffit d’effectuer un
parcours du fichier f et de ranger dans le fichier g chaque élément de f. les deux parcours
(lecture et construction) sont contrôlés par la même itération. On a :

Page 41
 Procédure copie (E f : fic de t ; S g : fic de t) ;
var c : t ;
Debut
Réecrire (g) ;
Relire (f) ;
Tant que ┐fdf (f) faire
lire (f, c) ;
ecrire (g, c) ;
Ftq ;
Fproc ;

2.5.11.2 Somme ou Concaténation de deux fichiers

A partir de deux fichiers f et g, on veut construire un troisième fichier h tel que h = f // g.

c'est-à-dire qui si f =< x1, x2, x3, …., xn> ; g = < y1, y2, y3, …., ym>
alors on obtient : h= < x1, x2, x3, …., xn, y1, y2, y3, …., ym >
L’algorithme consiste donc à effectuer la copie de f dans h, puis à compléter h par les
éléments de g.
Procédure concat ( E f, g : fic de t ; S h : fic de t) ;
Var c : t ;
Debut
Réecrire (h) ;
Relire(f) ;
tant que ┐fdf (f) faire
lire (f, c) ;
ecrire (h, c) ;
ftq ;
Relire(g) ;
tant que ┐fdf (g) faire
lire (g, c) ;
ecrire (h, c) ;
ftq ;
fproc ;
Remarque : on peut définir un algorithme de concaténation de p fichiers séquentiels.
2.5.11.3 Eclatement d’un fichier en plusieurs fichiers :
On veut construire m fichiers séquentiels (g1 , g2 , .., gm) à partir d’un seul fichier
séquentiel f en utilisant un critère Ф d’éclatement. Ce critère est en général une
application définie sur l’ensemble des valeurs des éléments du fichier dans l’ensemble
des m premiers nombres entiers. La technique d’écriture de l’algorithme de construction
des m fichiers utilise le fichier f comme fichier directeur. On peut schématiser ainsi
intuitivement l’algorithme : après avoir obtenu un élément de f, la fonction Ф est
évaluée et l’on peut, suivant la valeur délivrée par Ф, ranger l’élément de f dans le
Page 42
fichier adéquat. L’algorithme est en principe cohérant et se termine puisqu’il est dirigé
par le fichier f. Il faut évidement que Ф soit partout définie sur l’ensemble des valeurs de
f quelque soit le fichier.
Ce problème est très courant dans toutes les applications de gestion : ventilation d’un
fichier.
Remarque :
1. Un ou plusieurs fichiers (g1, g2 , …, gm) peuvent être vides.
2. L’ensemble des valeurs est en général formé d’exemplaires de valeurs structurés.
La fonction Ф fait alors intervenir un ou plusieurs champs de ces valeurs.
2.5.11.3.1 Eclatement d’un fichier à valeurs dans N en deux fichiers suivant
le critère de parité :
La fonction Ф est booléenne et détermine la parité de la valeur des éléments du fichier.
On appellera cette fonction pair. Elle délivre la valeur vrai si x est un nombre pair, faux
si x est un nombre impair.
On va construire deux fichiers, l’un contenant les nombres entiers pairs du fichier de
données, l’autre les nombres entiers impairs. On appellera fpair et fimpair ces deux
fichiers. Le fichier f de données est le fichier pilote.
On utilise un choix à deux alternatives (si sinon) permettant de choisir le fichier fpair ou
fimpair suivant la parité de l’élément de f.
Exemple : si f = < 2, 3, 1, 6, 8, 5, 4 > alors fpair = < 2, 6, 8, 4 > et fimpair = < 3, 1, 5 >
Procedure pairimpair ( E f : fic de entier ; S fpair, fimpair : fic de entier) ;
Var c : entier ;
Debut
Réécrire (fpair) ;
Réecrire (fimpair) ;
Relire(f) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
si c mod 2 =0
alors écrire (fpair, c)
sinon écrire (fimpair, c)
fsi ;
ftq ;
fin ;

2.5.11.3.2 Éclatement d’un fichier en deux fichiers suivant le rang de l’élément

Il s’agit ici d’éclater le fichier f en deux fichiers de telle sorte que tous les éléments de
rang pair (et non la valeur pair) soient rangés dans le fichier f2 et les éléments de rang
impair dans le fichier f1.
Exemple : si f = < 2, 3, 1, 6, 8, 5, 4 > alors f1 = < 2, 1, 8, 4 > et f2 = < 3, 6, 5 >.
Une solution consiste à remarquer que la suite 1,2, 3, 4, 5, .., 2i-1, 2i, … est une suite de
couples (2i-1, 2i) où chaque couple est formé d’un élément impair et d’un élément pair.
Page 43
Il suffit donc à chaque itération d’effectuer deux lectures et de ranger le 1er élément
dans f1 et le second dans f2. Pour la 2ème lecture il faut s’assurer que l’élément existe
bien en se protégeant par le prédicat fdf. L’algorithme est le suivant :
Procedure rpairimpair ( E f : fic de t ; S f1, f2 : fic de t) ;
Var c : t ;
Debut
Réécrire (f1) ;
Réecrire (f2) ;
Relire(f) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (f1, c) ;
si┐fdf (f)
alors
lire (f, c) ;
écrire (f2, c)
fsi ;
ftq ;
fin ;

2.5.11.3.3 Eclatement d’un fichier en plusieurs monotonies

Définition : on appelle monotonie croissante d’un fichier f= < x1, x2, x3, …., xn> tout
sous fichier non vide trié par ordre croissant fij tel que Xj> Xj+1 pour j < n ; Xi< Xi-1 pour
i > 1. On peut par analogie définir des monotonies décroissantes : on appelle monotonie
décroissante d’un fichier f = < x1, x2, x3, …., xn> tout fichier non vide trié par ordre
décroissant fij tel que Xj< Xj+1 pour j < n ; Xi> Xi-1 pour i > 1.
Exemple soit f = < 2, 10, -5, 18, 22, 14, 7, 16 >, il contient :
- des monotonies croissantes : 2, 10 ; -5, 18, 22 ; 14 ; 7, 16 ;
- ou les monotonies décroissantes : 2 ; 10, -5 ; 18 ; 22, 14, 7 ; 16
À partir de maintenant, on appellera monotonie une monotonie croissante.
On veut éclater le fichier f en deux fichiers f1 et f2 contenant respectivement les
monotonies de rang impair de f et les monotonies de rang pair de f.
Exemple : pour le fichier f = < 2, 10, -5, 18, 22, 14, 7, 16 >, on obtient :
f1 = < 2, 10, 14>, f2 = < -5, 18, 22, 7, 16 >.
Eléments d’analyse : l’algorithme est plus complexe que l’algo précedent.
La principale difficulté réside dans la détermination des monotonies. Soit un fichier
f = < x1, x2, x3, …., xr, xr+1, …, xt, xt+1, …, xn> avec 1< r ≤ t < n et xr… xt une
monotonie de f.
on a donc xr < xr-1, xr-1  à la monotonie précédente.
xt> xt+1, xt+1  à la monotonie suivante.

Page 44
On détecte la fin d’une monotonie lorsque la relation d’ordre (≤) n’est plus vérifiée. Il
suffit donc de garder deux valeurs consécutives pour pouvoir prendre une décision.
Pour choisir le fichier f1 ou f2, il suffit, comme dans l’algorithme précédant, de
disposer d’une variable booléenne « un » qui prend la valeur vrai ou faux permettant
l’écriture de la valeur de l’élément de f dans f1 ou f2. Cette variable booléenne change
de valeur (bascule) à chaque changement de monotonie.
On a donc :
Xi  f, i < n, xi ≤ xi+1 « un » garde sa valeur ;
Xi  f, i < n, xi > xi+1 « un » change de valeur ;
« un » implique f1 = f1 // xi+1 ; « ┐ un » implique f2 = f2 II xi+1
Afin de pouvoir comparer deux éléments consécutifs, il faut sauvegarder l’élément
précédent dans une variable que l’on appelle précédent. Ainsi comparer xi et xi+1
revient à comparer le contenu des variables « précédent » et « c » élément courant.
On suppose f non vide.
L’algorithme est le suivant :
Procedure monotonie (E f : fic de t ; S f1, f2 : fic de t) ;
Var c, precedent : t ; un : booléen ;
Debut
Relire (f) ;
Réécrire (f1) ;
Réécrire (f2) ;
Un  vrai ;
Lire (f, precedent) ;
Ecrire (f1, precedent) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
siprecedent > c
alorsun  non un ;
fsi ;
si un
alors ecrire ((f1, c)
sinon écrire (f2, c)
fsi ;
precedent c ;
ftq ;
fin.
2.5.11.3.4Fusion de plusieurs fichiers en un seul
Ce problème consiste à construire à partir de plusieurs fichiers séquentiels, un seul
fichier suivant un certain critère de fusion. Nous prenons comme exemple celui de
l’interclassement de deux fichiers triés.

Page 45
Interclassement (ou fusion) de deux fichiers triés : soient deux fichiers triés f et g à
valeurs dans un même ensemble V et munis de la même relation d’ordre. On veut
construire un fichier h trié contenant tous les éléments de f et de g.

a) Première solution avec une sentinelle s :

Pour simplifier l’algorithme, on va supposer que f et g sont munis d’une sentinelle s.
cette sentinelle s ne doit pas être un élément possible de f ; par exemple, si f contient des
entiers strictement positifs, alors s pourra être égale à 0.
Raisonnement par récurrence :
Appelons fs, gs et hs les fichiers f, g et h munis d’une sentinelle S. fs = f // S ; gs = g //
S ; hs = h // S.
Les deux fichiers étant triés, on commence par parcourir les deux fichiers fs et gs en
parallèle.
On sélectionne alors deux éléments cf et cg dont il faut écrire le plus petit des deux dans
le fichier hs. Ensuite, on remplace le plus petit des deux par son élément suivant. Et ainsi
de suite tant qu’il reste des éléments à traiter. Ensuite, on doit copier les éléments
restants du fichier non vide.
L’algorithme comprend donc deux parties :
- Le parcours parallèle des deux fichiers fs et gs ;
- Le traitement des éléments restants du fichier non vide.
Nous allons alors effectuer un raisonnement en deux parties : le 1er est consacré au
parcours en parallèle de deux fichiers fs et gs ; le 2ème au traitement des éléments
restants du fichier non vide. D’où l’Algorithme :
Procedure interclassement (E f, g : fic de t ; S h : fic de t) ;
Var cf, cg : t ;
Debut
Relire(f) ; relire (g) ; récrire (h) ; lire (f, cf) ; lire (g, cg) ;
tant que ( ┐fdf (f)) et ( ┐fdf (g)) faire
si cf ≤ cg
alors
ecrire (h, cf) ;
lire (f, cf) ;
sinon
écrire (h, cg) ;
lire (g, cg) ;
fsi ;
ftq ;
tant que ( ┐fdf (f)) faire
ecrire (h, cf) ;
lire (f, cf) ;
ftq ;

Page 46
 tant que ( ┐fdf (g)) faire
ecrire (h, cg) ;
lire (g, cg) ;
ftq ;

ecrire (h, cf) (ou écrire (h, cg)) ;

fin.

b) Deuxième solution avec une sentinelle « high-value » :

Chaque fichier est supposé terminer par une « high-value » notée H ; élément toujours
présent et supérieur à tous les éléments normaux ; il est logique d’ajouter cette sentinelle
au bout du fichier interclassé. Cette sentinelle H permet de simplifier l’algorithme, car
tous les éléments de f et g étant < à H, tous les éléments auront été traités dans la
première itération à condition d’utiliser le connecteur ou à la place de et.

Procedure interclassement2 (E fh, gh : fic de t ; S hh : fic de t) ;

Var cf, cg : t ;
Debut
Relire(fh) ; relire (gh) ; récrire (hh) ; lire (fh, cf) ; lire (gh, cg) ;
tant que ( ┐fdf (fh)) ou ( ┐fdf (gh)) faire
si cf ≤ cg
alors
ecrire (hh, cf) ;
lire (fh, cf) ;
sinon
écrire (hh, cg) ;
lire (gh, cg) ;
fsi ;
ftq ;
ecrire (hh, cf) { ou écrire (hh, cg)}
fproc ;
2.5.12 Algorithmes de mise à jour
Il s’agit d’insérer ou de supprimer des éléments d’un fichier. Dans un but de
simplification, on supposera que la mise à jour ne porte que sur un seul élément.
L’élément, comme pour les accès, peut être désigné soit par sa position soit par sa
valeur. D’autre par, le fichier peut être trié ou non.
Tous ces algorithmes nécessitent la création d’un nouveau fichier (sauf dans le cas
particulier de l’insertion en fin de fichier où l’on pourrait compléter le fichier).
2.5.12.1 Insertion d’un élément dans un fichier :
2.5.12.1.1 Aucun critère
On dispose d’un fichier f, d’une valeur « valinsert » que l’on désire ajouter au
fichier f. On a deux possibilités simples :
Page 47
Ajouter l’élément en tête du fic f ou bien l’ajouter en fin de fic f. ce qui revient à la
concaténation (que nous avons déjà traitée) de f avec une valeur. Le resultat est :
Soit « valinsert » // f
Soit f // « valinsert »
Dans le 1er cas, il faut toujours créer un autre fichier ce qui donne :
Procedure insertdeb (E valinsert : t ; E f : fic de t ; S g : fic de t) ;
Var c : t ;
Debut
Réécrire (g) ;
Ecrire (g, valinsert) ;
Relire (f) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
fin.

Dans le 2ème cas, on crée d’abord un autre fic par copie du fic f ; puis on ajoute la
valeur valinsert à la fin. On obtient alors :
Procedure insertfin (E valinsert : t ; E f : fic de t ; S g : fic de t) ;
Var c : t ;
Debut
Réécrire (g) ;
Relire (f) ;
tant que ( ┐fdf (f)) faire

lire (f, c) ;
écrire (g, c) ;
ftq ;
ecrire (g, valinsert) ;
fin.

2.5.12.1.2 Insertionpar position :

On donne la position k du nouvel élément valinsert. Il s’agit donc d’écrire un algo
d’insertion à la k ième place de l’élément valinsert dans le fic f.
Le premier raisonnement est le suivant : on construit le fichier g résultat de la
concaténation de trois sous fic : g = f1kII valinsert II fkn l’algorithme se décompose en
trois parties :
- copie des k-1 premiers éléments de f,
- ajout de l’élément valinsert,
- copie des n-k+1 éléments de f.

Page 48
 si k  [1 .. n+1], on obtient le fic cherché ;
si k = 1 on insert au debut (f1k-1 est vide) ;
si k = n+1, on insert à fin (fkn est vide),
si k > n +1, le problème d’insertion n’a plus son sens et il faut signaler cette
impossibilité dans le résultat de l’algo. On utilisera une variable booléen
« possible » qui prend vrai ou faux suivant que l’insertion a été ou non réalisée.
L’algorithme est le suivant :
Procédure insertk (E f : fic de t ; E valinsert : t ; E k : entier ; S g : fic de t, S
possible :booléen) ;
Var i :entier ; c : t ;
Debut
Relire (f) ;
Réecrire (g) ;
i1;
tant que ( ┐fdf (f))et (i< k) faire
lire (f, c) ;
ecrire (g, c) ;
i i+1 ;
ftq ;
si i = k
alors
ecrire (g, valinsert) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
possible vrai ;
sinon
possible faux ;
fsi ;
fpro ;

2.5.12.1.3 Insertion associative

1) Insertion après une valeur : on veut insérer la valeur valinsert après ou avant (on
choisit après) la valeur val dans le fic f.
Raisonnement : dans le cas où il y a plusieurs exemplaires de la valeur val, on
insert après la première occurrence de cette valeur. On peut donc dire que le fic
résultat g est la concaténation de trois sous fichiers : f’, <valinsert>, f’’ où f’
désigne les premiers éléments de f jusqu’à la rencontre de la valeur val qui sera la
dernière valeur de f’.en d’autres termes : f = f’ // f’’, f’ = f’’’ // <val>.

Page 49
 On peut comme précédemment, donner plusieurs solutions. L’insertion est
impossible dans le cas où la valeur val est absente du fic f.

Procédure inserval (E f : fic de t ; E val, valinsert : t ; S g : fic de t, S

possible : booléen) ;
Var c : t ;
Debut
Relire (f) ;
Réecrire (g) ;
Lire (f, c) ;
Ecrire (g, c) ;
tant que ( ┐fdf (f))et (c<>val) faire
lire (f, c) ;
ecrire (g, c) ;
ftq ;
possible (c = val) ;
sic = val
alors
ecrire (g, valinsert) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
sinon possible  faux
fsi ;
fproc ;

2.5.12.1.4 Insertion associative dans un fichier trié

On veut ajouter un élément dans un fichier trié f de telle sorte que l’on obtienne un fic
trié g. g contiendra tous les éléments de f et l’élément à ajouter.
On peut remarquer que, dans ce cas là, le problème de l’ajout est, d’un point de vue
logique, toujours possible, car on trouve toujours une place qui appartient à l’intervalle
[1 .. n+1] et qui permet l’insertion.
Exemple : f = < c, f, g, m>
Insertion de a < a, c, f, g, m>
Insertion de h < a, c, f, g, h, m>
Insertion de z < a, c, f, g, h, m, z>
a) 1ère Solution : raisonnement : on considère que g est la concaténation de trois
sous fichiers : g = f’// < valinsert> // f’’ où f = f’// f’’, f’< valinsert ≤ f’’
Page 50
 Cas particuliers :
- (f’ = <>), (f’’≠ <>) : valinsert ≤ f
- (f’ ≠ <>), (f’’= <>) : f < valinsert
- (f’ = <>), (f’’= <>) : g = < valinsert >
D’autre part comme f’ et f’’ sont triés, l’algorithme peut être décomposé en 3
parties et consiste alors :
1) Copier tous les éléments de f inférieurs à valinsert ;
2) Insérer l’élément valinsert
3) Copier le reste des éléments du fichier f
L’algorithme est le suivant :
Procedure insertrie (E f : fic de t ; E valinsert : t ; S g : fic de t) ;
Var c : t ;
Debut
Relire (f) ;
Réecrire (g) ;
Si fdf (f)
Alors ecrire (g, valinsert)
Sinon
Lire (f, c) ;
tant que ( ┐fdf (f)) et (c < valinsert) faire
écrire (g, c) ;
lire (f, c) ;
ftq ;
si c ≥ valinsert
alors
écrire (g, valinsert) ;
écrire (g, c) ;

sinon
ecrire (g, c) ;
écrire (g, valinsert) ;
fsi ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
fsi ;
fproc ;

2.5.12.2 Suppression d’un élément dans un fichier

On peut, comme dans le cas de l’insertion, supprimer le kième élément (suppression
par position) ou supprimer une valeur (suppression associative).
Page 51
 Dans le cas de la suppression associative, le fichier peut être trié, ce qui permet
d’accélérer l’algo en cas où l’élément que l’on veut supprimer est absent du fichier.
2.5.12.2.1 Suppression par position :
On veut supprimer le kième élément du fic f
a) 1ère solution : raisonnement : on considère que l’on construit un fic g qui soit la
concaténation de deux sous fichiers f1k-1 et fk+1n d’où g = f1k-1// fk+1n
L’algo se décompose en trois parties :
- Copie des k-1 premiers éléments de f
- Lecture du kième élément (sans copie)
- Copie des n-k derniers éléments de f.
Cas particulier : si k = 1, le fic f1k-1 est vide
Si k = n, le fic fk+1n est vide.
La suppression n’est possible que si 1 ≤ k ≤ n .si k ≤ 0 ou k > n la suppression est
impossible (le kième élément n’existe pas). On prévoit alors une variable « possible » de
type booléen permettant de savoir si l’algo a pu ou non supprimer le kième élément.
D’où l’algo :
Procedure supprimek (E f : fic de t ; E k : entier ; S g : fic de t ; S possible :
booléen) ;
Var c : t ; i : entier ;
Debut
Relire (f) ;
Réecrire (g) ;
I1;
tant que ( ┐fdf (f) et (i < k) faire
lire (f, c) ;
écrire (g, c) ;
i i +1 ;
ftq ;

si (i =k) et ┐fdf (f)

alors
lire (f, c) ;
tant que ( ┐fdf (f)) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
possible vrai ;
sinon possible  faux;
fsi ;
fproc

Page 52
 2.5.12.2.2 Suppression associative
Nous nous limitons au cas de la suppression de la 1ère occurrence de l’élément val dans
un fichier non vide. En appliquant les raisonnements précédents, on peut dire que le fic
résultat est la concaténation de deux sous fichiers f’ et f’’ tels que f = f’ // < val > // f’’,
val Є f.
La suppression n’est possible que si val Є f. on définit donc, comme précedement, une
variable booléenne « possible » qui indiquera si la suppression a été effectuer ou non.
Procedure supprimeval (E f : fic de t ; E val : t ; S g : fic de t ; S possible :
booléen) ;
Var c : t ;
Debut
Relire (f) ; Réecrire (g) ; possible  faux ;lire (f, c) ;
tant que ( ┐fdf (f) et (c ≠ val) faire
écrire (g, c) ;
lire (f, c) ;
ftq ;
sic = val
alors
possible vrai;
tant que ┐fdf (f) faire
lire (f, c) ;
écrire (g, c) ;
ftq ;
sinon écrire (g, c)
fsi
fproc

T.D. 3
1. Écrire un algorithme qui délivre le nombre d’éléments d’un fichier. On écrira cet
algorithme sous forme de procédure et de fonction.
2. écrire une fonction qui délivre la somme des éléments de rang pair d’un fichier de
nombres entiers.
3. écrire une fonction qui délivre la différence entre la somme des éléments de rang
impair et la somme des éléments de rang pair : (x1 – x2 + x3 – x4 + ….).
Écrire une deuxième version à l’aide d’une bascule.
4. écrire une fonction qui délivre la valeur du dernier élément du fichier

Page 53
5. écrire une fonction qui délivre la somme du premier élément et du dernier
élément du fichier (par convention, si le fichier ne contient qu’un seul élément x1,
le résultat sera égal à 2x1)
6. écrire une fonction qui calcule le nombre d’occurrences ‘une valeur « val » dans
un fichier
7. écrire une fonction qui calcule le rang de la dernière occurrence de la valeur
« val » dans un fichier
8. écrire une fonction qui délivre le nombre d’occurrences de la valeur « val » dans
un fichier trié.
9. écrire une fonction qui délivre le rang de la première occurrence de la valeur
« val » dans un fichier trié
10. écrire une procédure d’intersection de deux fichiers triés sans répétitions (le
fichier obtenu doit être trié sans répétition).
11. écrire une procédure d’insertion de la valeur « valinsert » après chaque
occurrence de la valeur « val » dans le fichier f.
12. écrire une procédure de suppression de toutes les occurrences de la valeur « val »
dans le fichier trié f.

Page 54
 Thème des Projets
I-A) On vous demande de réaliser un agenda numérique portant les informations
suivantes :
N° ordre, Nom, Prenom, Adresse, Téléphone, année de naissance, age.
Pour arrêter la saisie, taper * comme N° d’ordre.
a) Faites une déclaration possible de cet agenda ;
b) Ecrire la procedure de création et d’affichage des éléments de cet
agenda.
c) Ecrire une procédure qui n’affiche que les détenteurs de numéro de
téléphone ;
d) Ecrire une procédure qui affiche ceux qui ont l’âge supérieur à 70 ans.
e) Ecrire une procédure de : récherche d’un élément par le prénom, de tri
par le prénom, d’insertion d’un élément dans l’agenda trié et de
supression d’un élément par le numéro d’ordre;
Pour une bonne manipulation de ce programme, faire un menu qui
présente les différentes tâches citées ci-haut.
I-B) Pour une sauvegarge permanante des informations, utiliser les fichiers.
Ecrire une procédure de :
a) création du fichier
b) lecutre du fichier de telle sorte que les informations soient triées par le
prénom ;
c) Ecrire une procédure qui éclate le fichier principal en fichiers des détenteurs de
numéro de téléphone et ceux qui ne détiennent pas de numéro puis une
procédure qui affiche chacun des deux fichiers ;
d) Ecrire une procédure de récherche d’un élément dans le fichier par le prénom
e) Ecrire une procédure qui supprime ceux dont l’âge est supérieur à 70 ans dans
le fichier ;
f) Ecrire une procédure d’insertion d’un élément dans le fichier trié.
Page 55
Faire un menu qui contiendra les différentes tâches demandées.
II-A)Il vous est soumis de gérer une salle de classe de capacité 100 élèves.
Chaque élève dispose des informations suivantes : matricule (8 car),
Prénom (20 car) et nom (15 car), les trois notes variant de 0 à 10 de coéfficient
respectif 1,2,3, la moyenne qui égale au produit de la somme des notes multipliées
par leur coéfficient respectif divisée par la somme des coéfficients et la mention
(10 car).
Dans le champ mention, on affichera ‘Excellent’ si la moyenne est supérieure ou
égale à 9.00 ;
‘TBien’ si lamoyenne est entre 7.00 et 8.99 ;
‘Bien’ si la moyenne est entre 6.00 et 6.99 ;
‘Passable’ si la moyenne est entre 5.00 et 5.99 ;
‘Redouble’ si la moyenne est inférieure à 5.00.
On convient de taper * comme matricule pour arrêter la saisie.
f) Faites une déclaration possible cette gestion ;
g) Ecrire la procedure de création et d’affichage des étudiants de cette
salle.
h) Ecrire une procédure qui n’affiche que les moyennants ;
i) Ecrire une procédure qui affiche ceux qui ont la mention Bien.
j) Ecrire une procédure de : récherche d’un étudiant par le matricule, de tri
par ordre du mérite, d’insertion d’un élément dans la fiche triée et de
supression d’un étudiant par le matricule;
Pour une bonne manipulation de ce programme, faire un menu qui
présente les différentes tâches citées ci-haut.
II-B) Pour une sauvegarge permanante des informations, utiliser les fichiers.
Ecrire une procédure de :
a) création du fichier

Page 56
 b) lecutre du fichier de telle sorte que les informations soient triées par le
prénom ;
c) Ecrire une procédure qui éclate le fichier principal en fichiers des étudiants
qui ont la moyenne et ceux qui n’ont pas puis une procédure qui affiche
chacun des deux fichiers ;
d) Ecrire une procédure de récherche d’un élément dans le fichier par le
prénom
e) Ecrire une procédure qui supprime les redoublants dans le fichier ;
f) Ecrire une procédure d’insertion d’un étudiant dans le fichier trié.
Faire un menu qui contiendra les différentes tâches demandées.
III-A) Le Directeur d’une entreprise vous demande de faire la gestion de son
personnel en vous fournissant les informations suivantes :
Matricule (3 car) ; Nom (20 car), année d’engagement, salaire de base, durée (à
calculer), nombre d’enfants et salaire net (à calculer).
Une prime de 80000FG par enfantest accordé au personnel de l’entrepise et une
augmentation de 25% du salaire de base est accordée à tous ceux qui ont fait plus
de 5ans de service.
Ainsi, le salaire net sera égal au salaire de base+ les avantages accordés.
a) Faites une déclaration possible pour cette gestion ;
b) Ecrire la procedure de création et d’affichage du personnel de cette
entreprise.
c) Ecrire une procédure qui n’affiche que les détenteurs de numéro de
téléphone ;
d) Ecrire une procédure qui affiche les employés qui ont fait plus de
5ans de service.
e) Ecrire une procédure de : récherche d’un employé par le matricule,
de tri par le prénom, d’insertion d’un employé dans la fiche triée et
de supression d’un employé par le matricule;
Page 57
 Pour une bonne manipulation de ce programme, faire un menu qui
présente les différentes tâches citées ci-haut.
III-B) Pour une sauvegarge permanante des informations, utiliser les fichiers.
Ecrire une procédure de :
g) création du fichier
h) lecutre du fichier de telle sorte que les informations soient triées par le
prénom ;
i) Ecrire une procédure qui éclate le fichier principal en fichiers des employés
ayant fait plus de 50ans de service et ceux qui n’ont pas fait plus de 10ans puis
une procédure qui affiche chacun des deux fichiers ;
j) Ecrire une procédure de récherche d’un élément dans le fichier par le matricule
k) Ecrire une procédure qui supprime ceux qui ont fait 50ans de service au sein
de l’entreprise dans le fichier ;
l) Ecrire une procédure d’insertion d’un employé dans le fichier trié.
Faire un menu qui contiendra les différentes tâches demandées.

BONNE CHANCE

Page 58