L2 Informatique Algorithmique et Structures de données 2017-2018

Matricule : Nom : Prénom : Groupe :

Rattrapage (Durée 1.5 h)

Documents et Téléphones Portables Interdits.
Exercice1 (1 + 1 + 0.5 + 1 + 1 + 0.5 + 1.5
1.5 = 6.5
6.5 points):
Soit R un Arbre Binaire de Recherche (ABR) contenant des entiers.
1. Construire cet arbre à partir des valeurs suivantes : 50, 40, 20, 65, 55, 45, 10, 70, 25.
2. Ecrire la fonction « InsererABR » qui permet d’insérer une valeur dans un ABR
3. Déduire la procédure « CreerABR » qui permet de créer un ABR à partir de n valeurs lues.
4. Ecrire la procédure récursive « Requete_interval » qui permet d’afficher en ordre décroissant toutes
les valeurs d’un ABR comprises entre A et B ([A, B]) sachant que A<B.
5. Ecrire la procédure itérative « MinMax » qui permet de retourner les valeurs max et min de l’arbre R.
6. Donner le résultat de la suppression du minimum de l’arbre R de la question 1 (répéter l’opération
deux fois consécutives).
7. Ecrire la fonction « SupprimerMin » qui permet de supprimer le minimum de l’arbre R.
Remarque : Les algorithmes doivent être écrits en utilisant le modèle de l’arbre : CreerNoeud, LibererNoeud, Info,
FG, FD, aff_Info, aff_FG, aff_FD.
Solution Exercice 1 :
6. Suppression du minimum
1. L’arbre (1 point, une erreur -0.25, deux erreurs -0.75, plus de trois erreurs 0) Le minimum = 10 (0.25 point)

Le minimum = 20 (0.25 point)

4. Procedure Requete_Interval (R : ptrN, A, B : entier)
(1 point)
Si (R ≠ Nil) alors
Requete_Interval (FD(R), A, B)
Si (A ≤ Info(R) ≤ B) alors Ecrire (Info(R))
Requete_Interval (FG(R), A, B)
FSi
5. Procedure MinMax (R : ptrN, var mi, ma : entier) (1
point)
mi -∞ ; ma +∞
Si (R ≠ Nil) alors
P R
TQ (FG(P) ≠ Nil) faire P FG(P)
mi info(P)
P R
TQ (FD(P) ≠ Nil) faire P FD(P)
ma info(P)
FSI
1/8
Versions
Versions itératives
itératives Versions récursives
2. Fonction InsererABR (R :ptrN, x : entier) : ptrN (1 2. Fonction InsererABR (R :ptrN, x : entier) : ptrN (1
point) point)
P CreerNoeud(x) Si (R = Nil) alors retourner (CreerNoeud(x))
Si (R = Nil) alors retourner (P) Sinon
Sinon Si (info(Q)>x) alors
Q R ; inserer faux Aff_FG(R, InsererABR(FG(R), x))
TQ (non inserer) faire Sinon
Si (info(Q)>x) alors Aff_FD(R, InsererABR(FD(R), x))
Si (FG(Q) = Nil) alors
Aff_FG(Q, P) ; inserer vrai Retourner (R)
Sinon Q FG(Q) Fsi
Sinon
Si (FD(Q) = Nil) alors
Aff_FD(Q, P) ; inserer vrai
Sinon Q FD(Q)
FTQ
Retourner (R)
Fsi

3. Procedure CreerABR( Var R : ptrN, n : entier) (0.5 3. Procedure CreerABR( Var R : ptrN, n : entier) (0.5
point) point)
R Nil Si (n>0) alors
Pour i 1 à n faire Lire (x)
Lire (x) R InsererABR(R, x)
R InsererABR(R, x) CreerABR(R, n-1)
FP FSi
7. Fonction SupprimerMin (R :ptrN) : ptrN (1 point) 7. Fonction SupprimerMin (R :ptrN) : ptrN (1 point)
Si (R = Nil) alors retourner (Nil) Si (R = Nil) alors retourner (Nil)
Sinon Sinon
Si (FG(R)=Nil) alors //min se trouve à la racine Si (FG(R)≠Nil) alors
Q R Aff_FG(R, SupprimerMin(FG(R))
R FD(R) Retourner (R)
Sinon Sinon
//rechercher le minimum D FD(R)
P Nil ; Q R libererNoeud(R)
TQ (FG(Q) ≠ Nil) faire retourner (D)
P Q ; Q FG(Q) FSi
Aff_FG(P, FD(Q)) //le chaînage
FSi
libererNoeud(Q)
retourner (R)
FSi

2/8
 Exercice 2 (1 + 1.5
1.5 + 1.5 = 4 points) :

Soit « IND » un index des mots qui est défini par un tableau « Tab »de taille n où chaque case du tableau
« Tab » contient un entier qui représente la longueur du mot et un pointeur vers une liste linéaire chaînée
unidirectionnelle. Cette liste contient des mots de même longueurs à raison d’un mot par maillon. Le
tableau est trié selon l’ordre décroissant de la longueur du mot. Les listes sont triées par ordre alphabétique
(ordre croissant de A à Z).
type maillon = structure Const Max = 100 ;
val : chaîne de caractères type index = structure
suiv : * maillon Tab: Tableau [Max] de case
Fin Queue :entier
type ptrM = * maillon Fin
type case = structure
long : entier
tête :ptrM
Fin

Dans le but de supprimer un mot dans cet index, il est demandé d’écrire les modules suivants:
1. La fonction récursive « RechDichoTab » qui permet de faire la recherche dichotomique et de retourner
l’indice de la case du Tab contenant une longueur donnée (soit x) si elle existe, sinon elle retourne -1.
2. La fonction récursive « SuppLLC » qui permet de supprimer dans une liste linéaire chaînée ordonnée un
mot s’il existe.
3. En utilisant les fonctions précédentes, écrire la procédure « Supprimer (var ID : index, y : chaîne de
caractère) » qui permet de supprimer un mot « y » de l’index « ID ». Si la liste contenant le mot « y » devient
vide alors la case correspondante à sa longueur est supprimée du tableau Tab.
INDICATION. Vous pouvez utiliser les fonctions suivantes :
a. Longch(ch : chaine de caractère) : entier qui retourne le nombre de caractère dans ch.
b. Cmpch (ch1, ch2 : chaine de caractère) : entier qui compare les chaînes ch1 et ch2 et retourne une valeur négative
si (lexicalement) ch1 < ch2, nulle si ch1 = ch2 et positive si ch1 > ch2.

Solution Exercice 2 :
Fonction RechDichoTab (Tab : tableau[] de case, D, F,x : entier) : entier
Si (D>F) alors retourner (-1) (0.25)
Sinon
M (D+F) div 2
Si Tab[M].long = x alors retourner (M) (0.25)
Sinon
Si Tab[M]>x alors retourner (RechDichoTab (Tab, M+1, F,x)) (0.25)
Sinon (RechDichoTab (Tab, D, M-1,x)) (0.25)
Fin
Fonction SuppLLC (L:ptrM, y : chaine de caractère) : ptrM
Si (L = Nil) ou cmpch(valeur(L), y)>0) alors retourner (Nil) (0.5)
Sinon
Si (cmpch(valeur(L), y)<0)) alors Aff_suiv (L, SupprimerLLC(suivant(L), x) ) ; Retourner (L) (0.5)
Sinon P L ; L suivant (L) ; libérer (P) ; Retourner (L) (0.5)
Fin

3/8
Procédure Supprimer (var ID : index, y :chaine de caractère)
//1. Rechercher la case du tab qui contient des mots de même longueur que y
i RechDichoTab (ID.Tab, 0, ID.Queue, Longch(y)) ; (0.25)
//2. s’il existe déjà des mots de même longueur que y
Si (i ≠ -1) alors (0.125)
//3. supprimer le mot de la liste
ID.Tab[i].Tete SuppLLC(ID.Tab(i].Tete, y) (0.25)
//4. Si la liste devient vide
Si (ID.Tab[i].Tete = Nil) (0.125)
// 5. Faire un décalage à gauche (0.25)
Pour j i à ID.Queue-1 faire
ID.Tab[j] ID.Tab[j+1]
//6. Réinitialiser la dernière case (0.25)
ID.Tab[j].long 0
ID.Tab[j].Tete Nil
//7. Décrémenter la taille du tableau (0.25)
ID.Queue-- ;

4/8
 L2 Informatique Algorithmique et Structures de données 2017-2018

Matricule : Nom : Prénom : Groupe :

Exercice 3 (1 + 1.5 + 3 = 5.5 points)

Un polynôme peut être représenté par une LLC triée dans l’ordre décroissant des puissances où chaque
maillon contient un monôme qui est représenté par un exposant et un coefficient (non nul). Par
exemple, le polynôme P(x) = 2x5+3x4+ 0.5x2+ 1 est représenté par la liste suivante :
type monome = structure type maillon = structure
coef :réel val : monome
puiss : entier positif suiv : * maillon
Fin Fin
type ptrM = * maillon

En utilisant le modèle de LLC et sans créer des nouveaux maillons, écrire :

1. La procédure « Integrale (P) » qui permet de calculer l’intégrale du polynôme P.

2. La procédure « Derive(P) » qui permet de calculer la dérivée du polynôme P.
3. La procédure « Somme (P, Q) » qui permet de calculer la somme de deux polynômes P et Q (P P+Q),
sachant que le degré de P est supérieur ou égal au degré de Q.
Rappelons que, si P(x) = 2x5+3x4+ 0.5x2+1 et Q(x) = 2x4- 0.5x2- 3x - 5 alors
.
- L’intégrale de P :
- La dérivée de P : 10 12
- La somme de P et Q : P P+Q = 2x5+5x4-3 x-4
Remarque : Les algorithmes doivent être écrits en utilisant le modèle de liste: Allouer, Liberer, valeur,
suivant, aff_val, aff_suiv.
Solution Exercice 3 :
2. Procédure Derivee (Var P : ptrM) (1.5 point)
1. Procédure Intégrale (Var P : ptrM) (1 point) L P ; Q Nil
L P TQ (L ≠ Nil) faire
TQ (L ≠ Nil) faire v valeur (L)
v valeur(L) Si (v.puiss ≠ 0) alors
v.puiss ++ v.coef v.coef * v.puiss
v.coef v.coef/v.puiss v.puiss –
aff_val(L, v) aff_val (L, v)
L suivant(L) Q L
FTQ L suivant (L)
Sinon
Si (Q = Nil) alors
P suivant(L)
Liberer (L)
L P
Sinon
aff_suiv(Q, suivant(L))
Liberer (L)
L suivant(Q)
FSI
FSI
FTQ
5/8
Solution Exercice 3 :
3. Procedure Somme (var P : ptrM, Q : ptrM) (3 points)
T P ; F Nil
TQ ((T ≠ Nil) et (Q ≠ Nil))
v valeur (T)
Si (v.puiss = valeur(Q).puiss)
v.coef v.coef + valeur(Q).coef
Si (v.coef ≠ 0) alors
F T
T suivant(T)
Q suivant (Q)
Sinon
Si (F = Nil) alors //supprimer le premier
maillon de P
P suivant (T)
Liberer (T)
T P
Q suivant(Q)
Sinon
aff_suiv(F, suivant(T))
Liberer (T)
T suivant (F)
Q suivant (Q)
FSI
FSI
Sinon
Si (v.puiss > valeur(Q).puiss)
F T
T suivant (T)
Sinon
S suivant (Q)
aff_suiv(Q, T)
aff_suiv(F, Q)
F Q
Q S
FSI
FSI
FTQ
Si (Q ≠ Nil) alors aff_suiv(F,Q)

6/8
 Exercice 4 (2.5 + 2.5
2.5 = 5 points) :

Soit P une pile d’entiers implémentée de manière statique en utilisant un tableau de taille « max ».

1. Rappeler la structure de données et l’implémentation du modèle (InitPile, PileVide, PilePleine,

Sommet, Empiler et Depiler) de ce type de pile.
2. Soient deux piles statiques P1 et P2
d’entiers triés dans l’ordre croissant (le
maximum est au sommet). En utilisant le
modèle de pile de la question précédente,
écrire une fonction qui permet de créer
une pile P3 contenant les valeurs de P1
qui n’existent pas dans P2 et les valeurs de
P2 qui n’existent pas dans P1. La pile P3
obtenue est aussi triée dans l’ordre
croissant.

Solution Exercice 4 : Fonction Sommet(P :Pile) (0.5 point)

Question1 : (2.5 points) Si non PileVide(P) alors
Type Pile = structure (0.25 point) Retourner (P.Elts [P.sommet])
Elts : Tableau [max] d’entier Fin
sommet : entier
Fin
Procedure InitPile(Var P : Pile) (0.25 point)
P.sommet -1
Fin
Fonction PileVide (P : Pile) : booleen (0.25 point)
Retourner (P.sommet = -1)
Fin
Fonction PilePleine (P : Pile) : booleen(0.25 point)
Retourner (P.sommet = max-1)
Fin
Procedure Empiler (Var P : Pile, x : entier) (0.5 point)
Si non PilePleine(P) alors
P.sommet ++ ;
P.Elts[P.sommet] x ;
FSI
Fin
Procedure Depiler (Var P : Pile, Var x : entier) (0.5
point)
Si non PileVide (P) alors
x P.Elts[P.sommet]
P.sommet-- ;
Fin
7/8
Question2 : (2.5 points)
Fonction exo4 (P1, P2 : Pile) : Pile
InitPile(P3) ; InitPile(P)
TQ (non PileVide(P1) et non PileVide(P2)) faire
Si (Sommet(P1) < Sommet(P2)) alors
Depiler (P2, x)
Empiler (P, x)
Sinon
Si (Sommet(P1) > Sommet(P2)) alors
Depiler (P1, x)
Empiler (P, x)
Sinon
Depiler (P1, x)
Depiler (P2, x)
FSI
FSI
FTQ
TQ (non PileVide(P1)) faire
Depiler (P1, x)
Empiler (P, x)
FTQ
TQ (non PileVide(P2)) faire
Depiler (P2, x)
Empiler (P, x)
FTQ
TQ (non PileVide(P)) faire
Depiler (P, x)
Empiler (P3, x)
FTQ
Retourner (P3)

Bon courage

8/8