Professional Documents
Culture Documents
ASD-TD4 Avec Solution-Derniere Version-2023
ASD-TD4 Avec Solution-Derniere Version-2023
ASD – 2022/2023
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. 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
2
Solution
Exercice 1
Profil :
Insertion-triée : liste, élément liste
Préconditions :
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.
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
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
3
Maximum(P)= Si dépiler(P)== pile-vide alors sommet(P)
Sinon Si sommet(P) >maximum (dépiler(P)) alors sommet(P)
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)
4
Fonction recursive Fonction Itérative
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 esommet(P) faire
sinon P1empiler(P1, sommet(P))
retourner(empiler(supprimer(dépiler(P),e), Pdépiler(P)
sommet(P))) Ftq
fsi Pdépiler(P)
Fin Tantque P1pile-vide() faire
P empiler(P, sommet(P1))
P1dépiler(P1)
Ftq
Retourner (P)
Fin
3.
Algorithme SUPPRESSION Pour I=1 à N faire
Déclarations Lire(A)
Fonction pile-vide( ): pile Pempiler(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 P1P ;
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 Psupprimer(P,sommet(P1) ;
Début Fsi
Lire(N) P1 depiler(P1) ;
Lire (val) FTQ
Ppile-vide() Fin
Exercice 04
1. Profil:
pile-sup: pile, réel pile
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)
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))
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))
7
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))) P1ajouterfin(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
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).
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
8
Ajouter-deb(f, e) = si f==file-vide alors ajouter(f,e)
Sinon ajouter(ajouter-deb(supp-queue(f),e),queue(f))
Fonctionrecursive Fonctioniterative
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
9
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
……
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.
1
0
Instanciation des algos génériques :
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
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
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 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
1
1
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 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
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
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
1
3
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
1
4
2. Profil
Chercher255 : File étudiant.
Axiomes
Chercher255 (F) si Mat(tête(F)) ==255 alors tête(F)sinon Chercher255 (défiler(F))
1
5