Université Constantine 2-Abdelhamid Mehri

Faculté des Nouvelles Technologies de l'Information et de la

Communication Département de Tronc Commun MI

ASD – 2022/2023

Série d'exercices N°0 4

Exercice 01
Proposez une fonction récursive Insertion-triée (L,e), permettant d’insérer un élément e dans une
liste L déjà triée. Quels sont les types possibles de l’élément e.
NB : N’oubliez pas la phase de spécification de l’opération Insertion-triée, c.a.d : profil,
préconditions et axiomes de cette op en se basant sur le TAD LISTE.
Exercice 02
1. Montrer qu'il existe une équivalence entre les opérations du TAD LISTE et celles du TAD
PILE
2. Montrer qu'il existe une équivalence entre les opérations du TAD LISTE et celles du TAD
FILE
3. Enrichir les deux TAD PILE et FILE par l'opération Maximum qui, retourne le plus grand
élément d’une pile ou d'une file.
4. Ecrire une fonction récursive qui retourne le plus grand élément d’une pile de réels.
5. Ecrire une fonction itérative qui retourne le plus grand élément d’une file de réels.
Exercice 03
Etant donné le TAD PILE d’entiers (les éléments de la pile sont des nombres entiers).
1. Donner le profil de l’opération « supprimer » qui supprime un élément donné d’une pile,
sachant que cet élément est supposé appartenir à la pile.
2. Ecrire les fonctions récursive et itérative qui implémentent cette opération.
3. Ecrire un algorithme qui permet de:
 Construire une pile contenant N éléments entier set,
 Supprimer de cette pile tous les éléments inférieurs à une valeur entière donnée (utiliser la
fonction supprimer en2).

Exercice 04
Soit le TAD PILE décrivant une pile de nombres réels et soit un réel X donnée,
1. Définir une opération Pile-Sup qui construit à partir d'une pile donnée, la pile des éléments supérieurs à X.
2. Ecrire la fonction récursive implémentant l'opération Pile-Sup
3. Ecrire la function iterative correspondante
4. Ecrire un algorithme qui:
a. Construit une pile de 1000 nombres réels
b. Lit un nombreréel X
c. Eclate cette pile en deux piles P1 et P2; P1 contient tous les nombres supérieurs à X et P2 contient
tous les nombres inférieurs à X.

Exercice 05
Etant donné le TAD PILE de personnes identifiées par leurs noms (les éléments de la pile sont des
chaines de caractères).
1. Donner le profil de l’opération « concaténation » qui fusionne deux piles de personnes données.
1
 2. Sachant que cette opération permet de mettre tous les noms des personnes de la 2ème pile à la
fin de la 1ère pile de personnes. Donner les propriétés de cette opération sous forme d'axiomes
3. Ecrire la fonction récursive qui implémente cette opération.
4. Si nous voulons écrire une fonction itérative analogue, quelle solution proposezvous?
5. Ecrire un algorithme qui permet de:
 Construire deux piles de personnes de taille respectivement N1 etN2.
 Concatener les deux piles.
 Rechercher dans la pile résultat une personne de nom "BOUYOUCEF"
Exercice06
1- Ecrire les fonctions suivantes permettant de manipuler la structure de donnée FILE.
a. Chercher-File (F, e), permettant de vérifier si un élément e existe ou non dans une fileF.
b. Ajouter-deb (F, e), permettant d’ajouter un élément e au début d'une fileF.
c. Inverse (F), permettant d’inverser les éléments d’unefile.

2- Proposer l'implémentation la plus adéquate (Chainée ou contigue) pour chacune de cesfonctions.

Justifier votrechoix.
Exercice 07
1. Etant donnée la procédure:supp-queue (D F : file, R F1 : file) qui supprime le dernier élément d’une
file. Donner une fonction récursive qui teste si un mot donné, contenu dans une file est un mot miroir.
Miroir(ELLE)=vrai, Miroir(AXEXA)=vrai,Miroir(FILE)=faux

2. Donnerdanscecasl’implémentationlaplusappropriéepourlastructurededonnéefileutilisée.
Exercice 08
Etant donnée l'implémentation suivante de la sorte "Elément" dans le TAD File d'éléments.
Types: Elément : Etudiant
Etudiant= enregistrement
Nom, Prénom : chaine de caractères
Mat: entier
fin

1. Donner l'implémentation chainée (types et fonctions de base) de la structure de donnéesFiled'étudiants

dans ce cas.
2. Etant données la fonction Mat(D E: étudiant): entier, qui retourne le matricule d'un étudiant donné,
- Ecrire une fonction récursive (profil et axiome au préalable) qui retourne l'étudiant ayant le matricule 255
se trouvant dans une File d'étudiants.

2
 Solution
Exercice 1
Profil :
Insertion-triée : liste, élément liste
Préconditions :
aucune
Axiomes :
Insertion-triée (L,e)si est-vide (L) alors inserer (L, e, 1,)
sinon si e <accès( L,1) alors insérer (L, e, 1)
sinoninsérer(Insertion-triée (supprimer(L,1),e,1), accès( L,1))

Nous remarquons que pr les 2 premiers tests on fait la mm chose, donc on les regroupe, d’oul’axiome en
plus concis:
Insertion-triée (L,e)si est-vide (L) ou e <accès( L,1) alors insérer (L,1,e)
sinon insérer( Insertion-triée (supprimer(L,1),e,1), accès( L,1))

NB : le 1, au niveau des opérations de l’axiome précèdent, désigne le rang 1 ou la place 1 ou la position 1dans une
liste L = ( e1, e2, e3….., en). Ce rang 1 est indépendant des implémentations (chainée ou contiguë) de la liste L.

1. Ce 1 correspondra exactement à la position 1 (implémentée par entier)pr l’implémentation contiguë et par

conséquent l’axiome restera tel qu’il est ( en move gras précédent).

2. Ce 1 correspondraà la position 1 (implémentée par pointeur) pr l’implémentation chainée et sera donc l’adresse L
par conséquent l’axiome sera légèrement ajusté, comme suit :
Insertion-triée (L,e)si est-vide (L) ou e <accès( L,L) alorsinsérer (L,L,e)
sinon insérer( Insertion-triée (supprimer(L,L),e) ,L, acces( L,L))

Les types possibles de l’élément e sont les types ordonnés, donc : entier, réel, char et string. Aussi pour
l’ordre des éléments dans liste, il est quelconque.
Ainsi Elément peut être instancié par entier, réel, char et string. Vous voyez donc, 4 possibilités et
une seule solution générale.
Exercice2
1. Et Qst 2
Opérations du TAD LISTE PILE FILE

Liste-vide pile-vide file-vide

Insérer Empiler Enfiler ( ou ajouter)
Supprimer Dépiler Retirer
Accès Sommet Tête-f
--- --- Queue-f
--- ---

3.
Profil:
Maximum : pile réel
Maximum : file  réel
Variables: P: pile, F: file, e: réel
Préconditions
Maximum(P) définie ssiP≠pile-
vide Maximum(F) définie
ssiF≠file-vide
Axiomes
Maximum(P)= Si dépiler(P)== pile-vide alors sommet(P)
Sinon Si sommet(P) >maximum (dépiler(P)) alors sommet(P)
3
 Sinon maximum(dépiler(P))
Maximum(F)= Si retirer(F)== file-vide alors tête-f(F)
sinon Si tête-f(F) >maximum(retirer(F)) alors tête-f(F)
sinon maximum(retirer(F))

4. et 5.
Fonction (récursive) pour la Pile Fonction (itérative) pour la File
Fonction Maximum(Donnée P : Pile): réel Fonction Maximum(D F : file): réel
Déclarations Déclarations
Fonction pile-vide ( ): pile Max: réel
Fonction sommet ( D P: pile): réel Fonction file-vide ( ): file /
Fonction dépiler( D P: pile): pile Fonction tête-f ( D F : file): réel
Début Fonction retirer ( D F : file): file
Si dépiler(P)== pile-vide( ) alors retourner Début
(sommet(P)) Si retirer(F)== file-vide ( ) alors retourner tête-f(f)
Sinon Si sommet(P) >Maximum(dépiler(P)) sinon
alors retourner (sommet(P)) Max = tête-f(f)
sinon retourner (Maximum(dépiler(P))) Tant que f≠ file-vide() faire
Fsi Si Max < tête-f(f)
Fsi Alors Max = tête-f(f)
Fin Fsi
F= retirer(F)
ftq
retourner (Max)
Fsi
Fin

Exercice 03

1. Profil:
supprimer : pile, entier pile
_appartient_: entier, pile booléen
2. Avant d'écrire les fonctions nous devons associer aux deux opérations les axiomes définissant leurs
fonctionnalités.
Variables: P:pile,
e:entier Précondition
supprimer (P, e) n’est pas définie si e appartient P = faux ou appartient(e, P) = faux (l’élément
n’appartient pas à la pile)
Axiome
supprimer (P, e)  si e==sommet(P) alors dépiler(P)
sinon empiler (supprimer (dépiler(P),e),
sommet(P))
e appartient pile-vide  faux
e appartient P si e ==sommet(P) alors vrai sinon e appartient dépiler(P)

Fonction recursive Fonction Itérative

4
 Fonction Supprimer(Donnée P:pile, Donnée Fonction Supprimer(Donnée P:pile,Donnée e :entier) :pile
e :entier) :pile Déclarations
Déclarations Fonction pile-vide( ): pile
Fonction sommet(Donnée P :pile): entier Fonction sommet(Donnée P :pile): entier
Fonction dépiler(Donnée P :pile): pile Fonction dépiler(Donnée P :pile): pile
Fonction empiler(Donnée P :pile, Donnée e :entier) : Fonction empiler(Donnée P :pile, Donnée e :entier) : pile
pile P1:pile
Début Début
si e==sommet(P) alors P1 pile-vide()
retourner(dépiler(P)) Tantque esommet(P) faire
sinon P1empiler(P1, sommet(P))
retourner(empiler(supprimer(dépiler(P),e), Pdépiler(P)
sommet(P))) Ftq
fsi Pdépiler(P)
Fin Tantque P1pile-vide() faire
P empiler(P, sommet(P1))
P1dépiler(P1)
Ftq
Retourner (P)
Fin
3.
Algorithme SUPPRESSION Pour I=1 à N faire
Déclarations Lire(A)
Fonction pile-vide( ): pile Pempiler(P,A)
Fonction chercher-pile(Donnée P :pile, Donnée e:entier): booléen Finpour
Fonction empiler(Donnée P :pile, Donnée e :entier) : pile P1P ;
Fonction Supprimer(Donnée P :pile, Donnée e :entier) : pile TQ P1 <> pile-vide ( ) faire
Val, N, A, I : entiers Si sommet(P1)< X alors
P,P1 : pile Psupprimer(P,sommet(P1) ;
Début Fsi
Lire(N) P1 depiler(P1) ;
Lire (val) FTQ
Ppile-vide() Fin

Exercice 04
1. Profil:
pile-sup: pile, réel  pile

Variables P: pile; X: réel

Axiomes:
pile-sup(pile-vide, X)  pile-vide
pile-sup(P, X)  si sommet(P) > X alors
empiler(pile-sup(dépiler(P), X), sommet(P))
sinon pile-sup(dépiler(P), X)
2. Fonction récursive
Fonction Pile-Sup(D P: pile, Donnée X: réel):pile
Déclarations
Fonction pile-vide( ): pile
Fonction sommet(D p:pile): réel
Fonction dépiler(D p:pile): pile
Fonction empiler(D p:pile, D e: réel): pile
Début
si P==pile-vide( ) alors retourner pile-vide( )
sinon si sommet(P) > X alors
retourner(empiler(pile-Sup(dépiler(P), X), sommet(P)))
sinon retourner(pile-Sup(dépiler(P), X))
5
 fsi
fsi
Fin

3. Fonction itérative
Fonction Pile-Sup(D P: pile, Donnée X: réel):pile
Déclarations
Fonction pile-vide( ): pile
Fonction sommet(D p:pile): réel
Fonction dépiler(D p:pile): pile
Fonction empiler(D p:pile, D e: réel): pile
P1:pile
Début
P1= pile-vide()
Tantque P≠pile-vide( ) faire
si sommet(P)> X alors
P1=empiler(P1, sommet(P1))
fsi
P=dépiler(P)
ftq
retourner(P1)
Fin
4. Algorithme Question 4
Déclarations
P, P1, P2: piles
I: entier
R, X: réels
Fonction pile-vide( ): pile
Fonction sommet(D p:pile): réel
Fonction dépiler(D p:pile): pile
Fonction empiler(D p:pile, D e: réel): pile
Fonction Pile-Sup(D P: pile, Donnée X: réel):pile
Déclaration P1:pile
Début
P1= pile-vide()
Tantque P≠pile-vide( ) faire
si sommet(P)> X alors
P1=empiler(P1, sommet(P1))
fsi
P=dépiler(P)
ftq
retourner(P1)
Fin
Fonction Pile-Inf (D P: pile, Donnée X: réel):pile
Déclaration P1:pile
Début
P1= pile-vide()
Tantque P≠pile-vide( ) faire
si sommet(P) X alors
P1=empiler(P1, sommet(P1))
fsi
P=dépiler(P)
ftq
retourner(P1)
Fin

6
 Début
P=pile-vide( )
Pour I = 1 à 1000 faire
lire( R)
P= empiler(P, R)
fpour
Lire(X)
P1=Pile-Sup(P, X)
P2=Pile-Inf(P, X)
Fin

Exercice 05

Profil (dans le TAD PILE en instanciant le TAD ELEMENT par CHAINE de caractéres)

Concaténer : pile, pile pile

Axiomes
Concaténer(pile-vide,P1)  P1
Concaténer(P1,pile-vide) P1
Concaténer(P1,P2)  empiler(sommet(P1),Concaténer(dépiler(P1),P2))
Concaténer(P1,P2)  empiler(Concaténer(P1,dépiler(P2)), sommet(P2))

Variables P1,P2: Pile

Une autre solution en utilisant l'opération "Ajouterfin" spécifiée ainsi:

Ajouterfin: élément, pile pile
Ajouterfin(s, pile-vide)  empiler(s, pile-vide)
Ajouterfin(s, P1)
empiler(sommet(P1),ajouterfin(s,dépiler(P1)))

Concaténer(pile-vide, P1)  P1
Concaténer(P1,pile-vide)  P1
Concaténer(P1,P2) Concaténer (ajouterfin(sommet( P2), P1), dépiler (P2))

Variables s: chaine P1,P2: pile

1. et 4. Fonctions récursive et itérative correspondantes

Fonction récursive Fonction itérative (déduite de l’axiome)

Fonction Concaténer(Donnée P1, P2: pile):pile Fonction Concaténer (Donnée P1, P2: pile):pile
Déclarations Déclarations
Fonction pile-vide( ) : pile Fonction pile-vide( ) : pile
Fonction empiler(Donnée e: chaine, donnée P: pile):pile Fonction sommet(Donnée P: pile): chaine
Fonction sommet(Donnée P: pile): chaine Fonction dépiler(Donnée P: pile): pile
Fonction dépiler(Donnée P: pile): pile Fonction Ajouterfin(Donnée p: chaine, Donnée P: pile): pile
Début
Si P1≠pile-vide ( ) et P2≠pile-vide( ) alors Début
Retourner (empiler(sommet(P1), TantqueP2≠pile-vide( ) faire
Concaténer(dépiler(P1), P2))) P1ajouterfin(sommet( P2), P1)
sinon si P1=pile-vide( ) alors retourner(P2) P2 dépiler (P2)
sinon retourner (P1) ftq
fsi retourner P1
fsi Fin
Fin

7
5. Dans la partie déclaration de cette algorithme, nous n'avons pas rappeler la déclarations des fonctions de base
utilisées telles que: pile-vide(), sommet, dépiler et empiler supposées être déclarées dans la fonction Concaténer (mais
de préférences, ns mettons toutes les déclarations une fois pr toute ici).

Algorithme FUSION-FINAL TantqueN2≠0 faire

Déclarations / lire(S)
FonctionConcaténer(Données P1, P2: pile):pile P2empiler(S,P2)
Fonction Appartient(Donnée S: Chaine, donnée P:pile): booléen N2N2-1
Début ftq
Si P=pile-vide ( ) alors retourner(faux) RConcaténer(P1,P2)
sinon si sommet(P)=S alors retourner(vrai) Si appartient("Bouyoucef", R) alors
sinon retourner(appartient(S, dépiler(P)) écrire(" le nom cherché existe dans la liste")
fsi sinon écrire(" le nom cherché existe dans la liste")
fsi fsi
Fin FIN
N1, N2: entiers
S: chaine
P1,P2, R: pile
Début
lire(N1); lire(N2)
P1 pile-vide( ); P2 pile-vide( )
TantqueN1≠0 faire
lire(S)
P1empiler(S,P1)
N1N1-1
ftq

Exercice 06
1. Le profil de ces opérations
Chercher-file : file, élément  booléen
Ajouter-deb: file, élément  file
inverse: file file

Leurs propriétés sous forme d’axiomes sont :

Variables e: élément, f: file,
Chercher-file (file-vide, e) = faux
Chercher-file (f, e) = si e==tête (f) alors vrai sinon Chercher-file(retirer(f), e)

Ajouter-deb(f, e) = si f==file-vide alors ajouter(f,e)

Sinon ajouter(ajouter-deb(supp-queue(f),e),queue(f))

en ajoutant la définition de l'opération utilisée

supp-queue : file file
supp-queue (ajouter(f,x)) = si f=file-vide alors file-vide sinon F

Inverse(f) = si retirer(f)=file-vide ou f=file-vide alors f

sinon ajouter(inverse(retirer(f)), tête(f))

Fonctionrecursive Fonctioniterative

8
 Fonction Chercher-file (D F: file, D e : élément) : booléen Fonction Chercher-file (D F: file, D e : élément) : booléen
Déclarations Déclarations
Fonction tête-f (D F :file) : élément Fonction tête-f(D F :file) : élément
Fonction retirer (D F :file) : file Fonction retirer (D F :file) : file
Fonction file-vide () : file Fonction file-vide () : file
/* leurs corps dépendent de l’implémentation considérée pour /* leurs corps dépendent de l’implémentation considérée pour
la file, chaînée ou contiguë (voir cours) la file, chaînée ou contiguë (voir cours)
Début Début
Si F== file-vide ( ) Alors Retourner (faux) Tantque (F  file-vide ( ) ) et (tête-f(F)  e ) faire
Sinon début F= retirer(F)
Si e == tête-f(F) Alors Retourner (vraie) Fin tantque
Sinon Retourner (Chercher-file (retirer(F), e)) Si F== file-vide() alors retourner faux
Finsi sinon retourner vrai
Finsi fsi
Fin Fin
Fonctionrecursive Fonctionitérative
Fonction Ajouter-deb (D F: file, D e : élément) : file Fonction Ajouter-deb (D F : File, D e : élément) : File
Déclarations Déclarations :
Fonction file-vide ( ) : File Fonction file-vide ( ) : File
Fonction ajouter (D F : File, D e : élément) : File Fonction ajouter (D F : File, D e : élément) : File
Fonction supp-queue (D F : File) : File Fonction retirer (D F : File) : File
Fonction queue(D F : File) : élément Fonction tête-f (D F : File) : élément
/* leurs corps dépendent de l’implémentation considérée
Début pour la file, chaînée ou contiguë (voir cours)*/
si F==file-vide ( ) alors F1 : File
Retourner ajouter(F,e) Début
Sinon F1  file-vide ( ) ;
Retourner ajouter(ajouter-deb(supp-queue(F),e),queue(F)) F1  ajouter (F1, e) ;
TQ F <> file-vide ( ) faire :
Fsi F1  ajouter (F1, tête-f (F)) ;
F  retirer (F) ;
Fin
FTQ
Retourner (F1) ;
Fin
Fonctionrecursive Fonctionitérative
Fonction Inverse (D F: file) : file Fonction Inverse (D F: File) : File
Déclarations Déclarations
Fonction file-vide ( ) : File Fonction file-vide ( ) : File
Fonction ajouter (D F : File, D e : élément) : File Fonction ajouter (D F : File, D e : élément) : File
Fonction retirer (D F : File) : File Fonction retirer (D F : File) : File
Fonction tête-f (D F : File) : élément Fonction tête-f (D F : File) : élément
Fonction Pile-vide ( ) : Pile
Début Fonction empiler (D F : File, D e : élément) : Pile
si retirer(f)=file-vide ou f=file-vide alors Fonction depiler (D P: Pile) : Pile
retourner F Fonction sommet (D P : Pile) : élément
sinon /* leurs corps dépendent de l’implémentation considérée pour
la file, chaînée ou contiguë (voir cours)*/
retourner ajouter(inverse(retirer(F)), tête-f(F))
P :Pile ;
Fsi
Début
Fin
P pile-vide () ;
TQ F <> file-vide ( ) faire :
P  empiler ( P, tête-f (F)) ;
F  retirer (F);
FTQ
TQ P <> pile-vide ( ) faire :
F  ajouter (F, sommet (P)) ;
P  depiler (P);
FTQ
Retourner F;
Fin

On peut implémenter la fonction inverse on utilisant deux autres solutions avec l’opération supp-queue et
ajouter-deb ou on n’utilise pas une pile mais une autre file.
Dans la 1ere solution, on supprime le dernier élément de la file et l’ajoute à la deuxième file
……
9
 TQ F <> file-vide () faire :
F1  ajouter (F1, queue(F)) ;
F  supp-queue (F)
FTQ
…..
Pour la 2eme solution, on supprime la tete puis l’ajoute au debut avec la fonction ajouter-deb, comme suit :
……
TQ F <> file-vide () faire :
F1  ajouter-deb (F1, tête (F)) ;
F  retirer(F) ;
FTQ
…..
2. Proposer l’implémentation la plus adéquate (Chainée ou contiguë) pour chacune de ces fonctions.
Justifier votre choix.
Pour répondre à cette question, il faut :
1. Instancier l’algorithme générique par deux algorithmes, associé chacun à l’une des deux
implémentations (contiguë et chainée),
2. Ensuite poser des critères de comparaison :
Pour les critères, généralement c’est l’efficacité (complexité) et la réutilisation.
Nous commençons donc par Instancier l’algorithme générique, puis comparer.

N.B :Les deux implémentations (contiguë et chainée) de ces fonctions réutilisent les fonctions de
base des TADs étudiés d’une façon identique. Donc on s’intéresse au facteur d’efficacité pour
comparer les deux implémentations.

 Instanciation des algos génériques :

Implémentation contiguë Implémentation chainée

Fonction Chercher-file (D F: file, D e : élément) : booléen Fonction Chercher-file (D F: file, D e : élément) : booléen
Déclarations Déclarations
Fonction tête-f(D F :file) : élément Fonction tête-f(D F :file) : élément
Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction retirer (D F :file) : file Fonction retirer (D F :file) : file

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction file-vide () : file Fonction file-vide () : file

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Début Début
1 .Tantque (F  file-vide ( ) ) et (tête-f(F)  e ) faire 1.Tantque (F  file-vide ( ) ) et (tête-f(F)  e ) faire
2. F= retirer(F) 2. F= retirer(F)
Fin tantque Fin tantque
3.Si F== file-vide() alors 3.Si F== file-vide() alors
4. retourner faux 4.retourner faux
Sinon Sinon
5. retourner vrai 5. retourner vrai
fsi Fin fsi Fin

Toutes les instructions de 1 à 5 ont la même complexité pour les 2 implémentations sachant que la complexité de la
fonction retirer est d’ordre constant pour les 2. Idem pour la fonction File-vide ( )
 On peut choisir soit l’implémentation contiguë ou chainée.
Fonction Ajouter-deb (D F : File, D e : élément) : File Fonction Ajouter-deb (D F : File, D e : élément) : File
Déclarations : Déclarations :
Fonction file-vide ( ) : File Fonction file-vide ( ) : File
Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin
1
0
 Fonction ajouter (D F : File, D e : élément) : File Fonction ajouter (D F : File, D e : élément) : File
Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction retirer (D F : File) : File Fonction retirer (D F : File) : File

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction tête-f (D F : File) : élément Fonction tête-f (D F : File) : élément

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin
F1 : File F1 : File
Début Début
1. F1  file-vide ( ) ; 1. F1  file-vide ( ) ;
2.F1  ajouter (F1, e) ; 2.F1  ajouter (F1, e) ;
3.TQ F <> file-vide ( ) faire : 3.TQ F <> file-vide ( ) faire :
4. F1  ajouter (F1, tête-f (F)) ; 4. F1  ajouter (F1, tête-f (F)) ;
5. F  retirer (F) ; 5. F  retirer (F) ;
FTQ FTQ
6.Retourner (F1) ; 6.Retourner (F1) ;
Fin Fin

Toutes les instructions de 1 à 6 ont la même complexité pour les 2 implémentations sachant que la complexité des
fonctions ajouter, retirer, tête-f et File-vide est d’ordre constant pour les 2 implémentations.
 On peut choisir soit l’implémentation contiguë ou chainée.

Fonction Inverse (D F: File) : File Fonction Inverse (D F: File) : File

Déclarations Déclarations
Fonction file-vide ( ) : File Fonction file-vide ( ) : File
Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction ajouter (D F : File, D e : élément) : File Fonction ajouter (D F : File, D e : élément) : File
Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction retirer (D F : File) : File Fonction retirer (D F : File) : File

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction tête-f (D F : File) : élément Fonction tête-f (D F : File) : élément

Debut /* voir chap 3-partie2 : Implémentation contiguë FILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée FILE*/ fin

Fonction Pile-vide ( ) : Pile Fonction Pile-vide ( ) : Pile

Debut /* voir chap 3-partie2 : Implémentation contiguë PILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée PILE*/ fin

Fonction empiler (D F : File, D e : élément) : Pile Fonction empiler (D F : File, D e : élément) : Pile
Debut /* voir chap 3-partie2 : Implémentation contiguë PILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée PILE*/ fin

Fonction depiler (D P: Pile) : Pile Fonction depiler (D P: Pile) : Pile

Debut /* voir chap 3-partie2 : Implémentation contiguë PILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée PILE*/ fin

Fonction sommet (D P : Pile) : élément Fonction sommet (D P : Pile) : élément

Debut /* voir chap 3-partie2 : Implémentation contiguë PILE*/ fin Debut /* voir chap 3-partie2 : Implémentation chainée PILE*/ fin

P :Pile ; P :Pile ;
Début Début
1. P pile-vide () ; 1. P pile-vide () ;
2. TQ F <> file-vide ( ) faire : 2. TQ F <> file-vide ( ) faire :
3. P  empiler ( P, tête-f (F)) ; 3. P  empiler ( P, tête-f (F)) ;
4. F  retirer (F); 4. F  retirer (F);
FTQ FTQ
5. TQ P <> pile-vide ( ) faire : 5. TQ P <> pile-vide ( ) faire :
6. F  ajouter (F, sommet (P)) ; 6. F  ajouter (F, sommet (P)) ;
7. P  depiler (P); 7. P  depiler (P);
FTQ FTQ
8. Retourner F; 8.Retourner F;
Fin Fin

Toutes les instructions de 1 à 8 ont la même complexité pour les 2 implémentations sachant que la complexité des
fonctions ajouter, retirer, tête-f et File-vide est d’ordre constant pour les 2 implémentations. Idem pour les
1
1
fonctions empiler, depiler, sommet et pile-vide.
 On peut choisir soit l’implémentation contiguë ou chainée.

Exercice 07
Profil
miroir: file  booléen
Variables
F:file
Axiomes
miroir(F)  si F=file-vide ou retirer(F)=file-vide alors vrai sinon
si (tête(F)==queue(F)) alors miroir(retirer(supp-queue(F)))
sinon retourner faux

Fonction demandée

Fonction Miroir(Donnée F : file) :booléen Début

Déclarations Si (F==file-vide()) ou (retirer(F)==file-vide()) alors
F1 : file Retourner vrai
Procédure supp-queue (Donnée F : file, Sinon
Résultat F1 : file) Si (tête(F)==queue(F)) alors
Fonction file-vide( ) : file Supp-queue(F, F1)
Fonction queue-f(Donnée F : file) : élément Retourner(miroir(retirer(F1)))
Fonction tête-f(Donnée F : file) : élément Sinon retourner faux
Fonction retirer(Donnée F : file) : file Fsi
Fsi
Fin

L’implémentation la plus appropriée est l’implémentation contiguë suivante :

1
2
 Types: Fonction retirer( D F: file): file
Élément=caractère Début
file =enregistrement F.tête= (F.tête  1);
Tab: tableau [n] de caractères F.plein = faux
Tête, queue: entier retourner(F)
Plein: booléen Fin
Fin Fonction tête-f ( D F: file): élément
Fonction file-vide( ) : file Début
Déclaration Retourner F.Tab[F.tête]
F: file fin
Début Fonction queue-f ( D F: file): élément
F.plein = faux Début
F.tête=F.queue=1 Retourner F.Tab[(F.queue ө 1)]
Retourner F Fin
fin
Procédure supp-queue (Donnée F : file, Résultat F1 : file)
Début
F1.tête=F.tête ;
F1.tab=F.tab ;
F1.queue= (F1.queue ө 1)
F1.plein = faux
Fin

Exercice 08

1. Déclarations
Types:
File=enregistrement
ftête, fqueue: pointeur de cellule
Fin

Cellule= enregistrement
Info: Etudiant
Suiv : pointeur de cellule
Fin

Etudiant= enregistrement
N, P : chaine de caractères
Mat: entier
Fin

Fonction File-vide( ): pile

Déclaration
F: file
Début
F.ftête = Null
F.fqueue = Null
Retourner F
Fin

Fonction ajouter (D F: file, Donnée e: étudiant): file

Déclaration
Nouv: pointeur de cellule
Début
Nouv = allouer(cellule)
Nouv.info=e
Nouv.suiv=Null
Si F=file-vide() alors
1
3
F.ftête= Nouv
Sinon F.fqueue.suiv= Nouv
fsi
F.fqueue= Nouv
retourner(F)
Fin

Fonction retirer (D F: File): File

Début
F.ftête= F.ftête.Suiv
Si F.ftête= = Null /* cas d’une file avec un seul élément */
Alors F.fqueue = Null
Fsi
retourner(F)
Fin

Fonction tête ( D F:file): étudiant

Début
Retourner F.ftête.Info
Fin

Fonction queue ( D F:file): étudiant

Début
Retourner F.fqueue.Info
Fin

2. Profil
Chercher255 : File étudiant.

Axiomes
Chercher255 (F)  si Mat(tête(F)) ==255 alors tête(F)sinon Chercher255 (défiler(F))

Fonction Chercher255 (Donnée F:file): étudiant

Déclarations
Fonction Mat(D E: étudiant): entier
Fonction tête (D F:file): étudiant
Fonction retirer(D F:file): file
Début
Si Mat(tête(F))==255 alors retourner(tête(F))
sinon Retourner(Chercher255 (retirer(P)) )
Fsi
Fin

1
4