Vous êtes sur la page 1sur 6

EMSE-CMP

ISMEA

Piles & Files à l’aide de tableaux

Exercice I : Pile (LIFO : « last in, first out »)

On désire réaliser la notion de pile à l'aide d'une structure de données définie comme suit :

enreg Tpile
Tobj Elts[MAX]
entier NbElts
finenreg

Le type Tpile est un enregistrement comportant 2 champs :


Elts : tableau devant contenir les éléments de la pile. La capacité de la pile est définie par MAX.
Le type des éléments est Tobj.
NbElts : nombre d’éléments dans la pile. On supposera que les éléments de la pile sont rangés
dans l’ordre des indices croissants. Pour une pile vide, NbElts doit être égal à zéro.

I.1) Proposez un jeu d'algorithmes pour les opérations suivantes :

procédure initialiser (résultat Tpile pile)


procédure empiler (résultat Tpile pile, valeur Tobj E)
procédure depiler (résultat Tpile pile, résultat Tobj E)
fonction pilevide (valeur Tpile pile) retour entier
fonction pilepleine (valeur Tpile pile) retour entier

I.2) Ecrire un algorithme vérifiant l’existence d’un élément de valeur e dans la pile. Ce traitement devra
être basé sur une recherche dichotomique de l’indice de l’élément du tableau contenant la valeur e (la
recherche pouvant ne pas aboutir si un tel élément n’existe pas). Le principe d’une telle recherche sur
un tableau T de N éléments numérotés de 1 à N est le suivant :

- on accède à l’élément i = N / 2 (division entière de N par 2) ;


- si T[i] = e, on a gagné ;
- si T[i] < e, on itère la recherche aux éléments (i + 1) .. N du tableau ;
- enfin, si T[i] > e, on itère le processus de recherche aux éléments 1 .. (i - 1) ;
- on arrête les itérations lorsque l’intervalle de recherche est réduit à 1 élément.

I.1.1 Procedure Initialiser


1. procédure initialiser (résultat Tpile pile)
2. début
3. pile.NbElts ← 0
4. fin

SolExoAlgo 1 PileFILEtableau
I.1.2 Procedure Empiler
1. procédure empiler (résultat Tpile pile, valeur Tobj E)
2. début
3. si pilepleine(pile) alors
4. Ècrire(“pile pleine”)
5. sinon
6. pile.Elts[pile.NbElts] ← E
7. pile.NbElts ← pile.NbElts + 1
8. finsi
9. fin

I.1.3 Procedure Depiler


1. procédure depiler (résultat Tpile pile, résultat Tobj E)
2. début
3. si pilevide(pile) alors
4. Ècrire(“pile vide”)
5. sinon
6. pile.NbElts ← pile.NbElts - 1
7. E ← pile.Elts[pile.NbElts]
8. finsi
9. fin

I.1.4 Fonction Pilevide


1. fonction pilevide (valeur Tpile pile) retour booléen
2. début
3. retour pile.NbElts = 0
4. fin

I.1.5 Fonction Pilepleine


1. fonction pilepleine (valeur Tpile pile) retour booléen
2. début
3. retour pile.NbElts = MAX
4. fin

I.2 Fonction RechercheDichotomique


1. fonction recherchedichotomique (valeur Tpile pile, valeur entier e) : retour entier
2. entier premier, dernier, index
3. début
4. premier ← 0
5. dernier ← pile.NbElts - 1
6. tant que premier <= dernier faire
7. index ← (premier + dernier) / 2
8. si e = pile.Elts[index] alors
9. retour index
10. si e < pile.Elts[index] alors
11. dernier ← index - 1
12. sinon
13. premier ← index + 1
14. fsi
15. fin tantque
16. retour MAX
17. fin

SolExoAlgo 2 PileFILEtableau
Exercice II : File (FIFO : « first in, first out »)
On veut maintenant réaliser la notion de file à l'aide de la structure de données définie ci-après :

enreg Tfile
Tobj Elts[MAX]
entier id
entier NbElts
finenreg

Les 3 champs du type Tfile ont la signification suivante :


Elts : tableau devant contenir les éléments de la file ; la capacité de la file est définie par MAX.
Id : indice de l’élément le plus ancien dans la file si NbElts est non nul. La file est gérée comme un
buffer circulaire ; le contenu de la file est défini par les indices compris entre Id et (Id+Nbelts) mod
MAX (a mod b désignant le reste de la division entière de a par b).
Nbelts : nombre d’éléments dans la file (0 pour une file vide).

Proposez un jeu d'algorithmes pour les opérations suivantes :

procédure initialiser (résultat Tfile file)


procédure ajouter (résultat Tfile file, valeur Tobj E)
procédure retirer (résultat Tfile file, résultat Tobj E)
fonction filevide (valeur Tfile file) retour entier
fonction filepleine (valeur Tfile file) retour entier

Le type Tfile est un enregistrement comportant 3 champs :


Elts : tableau devant contenir les éléments de la pile. La capacité de la pile est définie par MAX;
Id : indice de l'élément le plus ancien dans la file si NbElts est non nul. La file est gérée comme un
buffer circulaire. Le contenu de la file est défini par les indices compris entre Id et (Id+NbElts) mod
MAX ;
NbElts : nombre d'éléments dans la file.

II.1 Procedure initialiser


1. procédure initialiser (résultat Tfile file)
2. début
3. file.NbElts ← 0
4. file.Id ← 0
5. end

II.2 Procedure ajouter


1. procédure ajouter (résultat Tfile file, valeur réel E)
2. début
3. si filepleine(file) alors
4. Ècrire(“file pleine”)
5. sinon
6. file.Elts[(file.Id + file.NbElts) mod MAX] ← E
7. file.NbElts ← file.NbElts + 1
8. finsi
9. fin

SolExoAlgo 3 PileFILEtableau
II.3 Procedure retirer
1. procédure retirer (résultat Tfile file, résultat réel E)
2. début
3. si filevide(file) alors
4. Ècrire(“file vide”)
5. sinon
6. E ← file.Elts[file.id]
7. file.id ← (file.Id + 1) mod MAX
8. file.NbElts ← file.NbElts - 1
9. finsi
10. fin

II.4 Fonction filepleine


1. fonction filepleine (valeur Tfile file) retour booléen
2. début
3. retour file.NbElts = MAX
4. fin

II.5 Fonction filevide


1. fonction filevide (valeur Tfile file) retour booléen
2. début
3. retour file.NbElts = 0
4. fin

SolExoAlgo 4 PileFILEtableau
Exercice III : File d’attente avec priorité
Dans cet exercice, on suppose que tout élément est muni d'une priorité représentée par un entier qui
doit être précisé au moment de l'ajout de l'élément dans la file. La procédure de retrait doit maintenant
chercher l'élément le plus prioritaire. On s'intéresse à une implémentation efficace des opérations.

La file d'attente sera définie par 2 structures de données : Telt et TfilePrio


enreg Telt
entier priorite
Tobj obj
finenreg

Chaque élément de la file d'attente est décrit par un enregistrement de type Telt comportant 2 champs
:
priorite : entier représentant la priorité de l'élément
obj : une valeur d'un type Tobj non précisé décrivant l'élément
enreg TfilePrio
Telt elts[MAX]
entier nbelts
finenreg

Donnez une implémentation des fonctions ajouter et retirer dans les 2 cas suivants :
1. On décide pour la procédure ajouter de ranger les éléments dans un ordre quelconque. Ce qui
implique que la procédure retirer doit parcourir la liste pour extraire l'élément prioritaire, puis
“tasser” le tableau pour qu'il n'y ait pas de trous.
2. On décide dans la procédure ajouter de maintenir les éléments par ordre de priorité croissante.

Les procédures ajouter et retirer sont déclarées comme suit :


procédure ajouter (résultat TfilePrio file, valeur entier prio, valeur Tobj obj)
procédure retirer (résultat TfilePrio file, résultat Tobj obj)

C'est une file d'attente dans laquelle chaque élément est caractérisé par une priorité. Chaque insertion
d'un élément dans la file doit préciser la priorité de l'élément en question. Les retraits se font par ordre
de priorité décroissante. On supposera que les éléments de la file sont d'un type Tobj non précisé. On
cherche une implémentation efficace d'une telle file.

III.1 Solution 1 : tableau non trié

III.1.1 Procedure ajouter

1. procédure ajouter (résultat TfilePrio file, valeur entier prio, valeur Tobj obj)
2. début
3. si filepleine(file) alors
4. Ecrire(“ajout impossible : file pleine”)
5. sinon
6. file.elts[file.nbelts].obj ← obj
7. file.elts[file.nbelts].priorite ← prio
8. file.nbelts ← file.nbelts + 1
9. finsi
10. fin

SolExoAlgo 5 PileFILEtableau
III.1.2 Procedure retirer

1. procédure retirer (résultat TfilePrio file, résultat Tobj obj)


2. entier i, imax, maxprio
3. début
4. si filevide(file) alors
5. Ecrire("retrait impossible : file vide")
6. sinon
7. maxprio ← file.elts[0].priorite
8. imax← 0
9. pour i de 1 à file.nbelts - 1 faire
10. si file.elts[i].priorite > maxprio alors
11. imax ← i
12. maxprio ← file.elts[i].priorite
13. finsi
14. finpour
15. obj ← file.elts[imax].obj
16. pour i de imax + 1 à file.nbelts - 1 faire
17. file.elts[i - 1] ← file.elts[i]
18. finpour
19. file.nbelts ← file.nbelts - 1
20. finsi
21. fin

III.2 Solution 2 : tableau trié par ordre de priorité croissante

III.2.1 Procedure ajouter


1. procédure ajouter (résultat TfilePrio file, valeur entier prio, valeur Tobj obj)
2. entier i
3. début
4. si filepleine(file) alors
5. Ecrire("ajout impossible : file pleine")
6. sinon
7. i ← file.nbelts
8. tantque i > 0 et file.elts[i - 1].priorite > prio faire
9. file.elts[i] ← file.elts[i - 1]
10. i←i-1
11. fintantque
12. file.elts[i].priorite ← prio
13. file.elts[i].obj ← obj
14. file.nbelts ← file.nbelts + 1
15. finsi
16. fin

III.2.2 Procedure retirer

1. procédure retirer (résultat TfilePrio file, résultat Tobj obj)


2. début
3. si filevide(file) alors
4. Ècrire("retrait impossible : file vide")
5. sinon
6. obj ← file.elts[file.nbelts - 1].obj
7. file.nbelts ← file.nbelts - 1
8. finsi
9. fin

SolExoAlgo 6 PileFILEtableau