L2 Informatique Algorithmique et Structures de Données 2016-2017

Solution de Rattrapage (1h30mn)

Exercice 01 (1.25 + 1.25 = 2.5 points):

1. Pour chaque description, donner le nom de l’algorithme correspondant (par sélection, par insertion,
à bulles, par fusion, rapide, par ABR, par TAS, par AVL) et la classe de sa complexité (linéaire, quasi-
linéaire, quadratique, logarithmique, polynomiale ou exponentielle)1.
Nom Principe Classe de complexité
A Bulles a. Inverser deux éléments successifs mal classés et Quadratique
recommencer jusqu'à ce qu’on ne peut plus inverser.
Par AVL b. Parcours en inordre un arbre binaire de recherche Quasi linéaire
équilibré.
Par sélection c. Placer le plus petit élément au début, puis le second Quadratique
plus petit élément à la deuxième position et ainsi de
suite jusqu'à ce que la liste soit entièrement triée.
Par fusion d. Interclasser deux listes triées de sorte à ce que la liste Quasi linéaire
finale soit triée.
Par insertion e. Insérer un élément dans une liste d'éléments déjà Quadratique
triés.
2. Pour chaque description, donner le nom de structure séquentielle (LLC unidirectionnelle, LLC
bidirectionnelle, LLC circulaire, File, File prioritaire, Pile, Pile prioritaire)2.
Nom Description
LLC circulaire
a. C’est une collection d’éléments où le premier élément peut être n’importe
quel élément.
File/ Pile prioritaire
b. C’est une collection d’éléments dans laquelle l’ajout se fait dans la bonne
position.
File
c. C’est une collection d'éléments dans laquelle l’ajout se fait à la fin alors que
le retrait se fait au début.
LLC bidirectionnelle
d. C’est une collection d’éléments que l'on peut parcourir dans les deux sens
Pile
e. C’est une collection des éléments dans laquelle l’insertion (ajout) et la
suppression (retrait) se font à une seule et même extrémité

1 Le nom de l’algorithme et la classe de complexité devront être les deux justes pour avoir 0.25, sinon c’est un zéro
2
Une réponse fausse annule une réponse juste.
Exercice 02 (1 + 1 + 1 + 1 + 1.5 + 0.5 = 6 points):
1. Fonction RechDicho(Tab :Tableau, bi, bs, x 2. Fonction RechSeqLLCbd (L :ListeBD, x :
:entier) : entier [vue en chapitre de entier) : * maillonBD [vue en TD4 pour
récursivité] LLC unidirectionnelle
Si (bi<=bs) alors Si L.Tete = Nil alors retourner (Nil)
mil  (bi+bs) DIV 2 ; Sinon
Si (Tab[mil]=x) Alors retourner (mil) Si valeur (L.Tete) = x alors retourner (L.Tete)
Sinon Sinon
Si (Tab[mil]>x) Alors L.Tete  suivant (L.Tete)
Retourner (RechDicho(Tab, bi, mil-1, x)) retourner (RechSeqLLCbd (L, x))
Sinon
Retourner(RechDicho(Tab, mil+1, bs, x))
Sinon Retourner (-1)
3. Fonction RechMilieuLLCbd(L :ListeBD) : * 4. Fonction RechDichoLLCbd(L :ListeBD, x
maillonBD :entier) : *MaillonBD
Var T, Q : * MaillonBD Si (L.tete= Nil) ou (L.queue= Nil) alors
T = L.Tete ; Q = L.Queue; Retourner (Nil)
TQ ((T≠Nil)et(Q≠Nil)et ((T ≠ Q) ou (precedent(T) Sinon
≠ Q))) mil  RechMilieurLLCbd(L);
{ Si (valeur(mil)=x) Alors retourner (mil)
T  suivant(T); Sinon
Q  precedent(Q); Si (valeur (mil)>x) Alors
} L.Queue precedent (mil)
retourner Q; Retourner (RechDichoLLCbd (L, x))
} Sinon
L.tete suivant (mil)
Retourner(RechDichoLLCbd (L, x))

Calcul de Complexité
RechDichoTab [vu en RechSeqLLCbd RechDichoLLCbd
cours]
n : la taille du tableau n : la taille de la liste n : la taille de la liste
T(n) = T(n /2) + c T(n) = T(n-1) + c T(n) = T(n /2) +
En appliquant le THM2 En appliquant le THM1 TRechMilieu(n)
avec a = 1, b = 2 et k = 0, avec a = 1 et T(0) = 0, TRechMilieu(n) = n/2 + b
on trouve on trouve TRechMilieu(n) = O(n)
T(n) = O (log2 (n)) En appliquant le THM2
avec a = 1, b = 2 et k = 1,
Donc T(n) = O(n) on trouve
T(n) = O (n)
Classe Logarithmique Linéaire Linéaire

Conclusion

Recherche Dichotomique Recherche Séquentielle

Classe de complexité Linéaire Linéaire

Nombre de parcours de LLC Log2 (n) fois (A chaque fois on Une seule fois
divise la liste en deux)

Conclusion Le meilleur principe dans LLC

ordonnée
Exercice 03 (1 + 0.75 + 1 + 0.25 = 3 points):
1. Procédure SupprimerLLC (L:*maillon, 2. Procédure SupprimerLLC_tous (L:*maillon,
v:entier) [vue en cours] v:entier) [vue aussi en cours]
PL; Qnil Début
TQ ((P  nil) et (valeur (P)  v) ) PL; Qnil
QP; P suivant (P) TQ (P  nil)
FTQ TQ ((P  nil) et (valeur (P)  v) )
Si (P  nil) alors QP; P suivant (P)
Si Q = nil alors FTQ
L  suivant (P); Si (P  nil) alors
Sinon Si Q = nil alors
aff_suiv(Q,suivant (P)); L  suivant (P); SL;
libérer (P) Sinon
aff_suiv(Q,suivant (P)); Ssuivant (P);
libérer (P)
P S;
FTQ
3. Fonction SupprimerLLC (L:*maillon, 4. Fonction SupprimerLLCtous (L:*maillon,
v:entier) : *maillon v:entier) : *maillon
Si (L = Nil) alors retourner (Nil) Si (L = Nil) alors retourner (Nil)
Sinon Sinon
Si (Valeur(L)  x) alors Si (Valeur(L)  x) alors
Aff_suiv (L, SupprimerLLC(suivant(L), x) Aff_suiv (L, SupprimerLLCtous(suivant(L),
Retourner (L) x)
Sinon Retourner (L)
PL ; Lsuivant (L) ; libérer (P) ; Sinon
Retourner (L) PL ; Lsuivant (L) ; libérer (P) ;
Retourner (SupprimerLLCtous(L, x))
Exercice 04 ((0.25 + 0.25 + 0.25 + 0.5 + 1.5 = 2.75) + (0.5 + 1 + 1 + 1.5 = 4) + (1.5 + 0.25 = 1.75) = 8.5
points)

1. a. Dessin de l’arbre 1.b structure de données 1.d. Fonction CreerNoeud

(x : entier)
TYPE Tnoeud= STRUCTURE Allouer(P) ;
Info : entier Aff_info (P, x);
Père, FG, FD : *Tnoeud Aff_FG (P, Nil);
FIN Aff_FD (P, Nil);
1.c les modules à ajouter : Aff_Pere (P, Nil);
Retourner (P);
Aff_père (Q, P :*Tnoeud)
Père (Q :*Tnoeud)

1.e : Transformer statique  dynamique

R  Nil ;
Racine  2 ; (par exemple)
Fonction Tranformer (Tab : Tableau, racine : entier, R : * Maillon) : * Maillon
Si (racine = -1) alors retourner (Nil)
Sinon
T CreerNoeud(Tab[racine].Info) ;
Si (R = Nil ) alors retourner (T)
Sinon
G Tranformer(Tab, Tab[racine].FG, R) ; D Tranformer(Tab, Tab[racine].FD, R) ;
Aff_FG(R, G) ; Si (G≠Nil) alors aff_pere(G, R)
Aff_FD(R, D); Si (D≠Nil) alors aff_pere (D, R)
Retourner(R)
FSI

2.a. l’arbre « AD » et un ABR non AVL car

- pour tout nœud P, on a info (FG(P)) < info (P) <= info (FD(P)) si FG(P)≠ Nil et FD(P)≠ Nil
- il existe un nœud (qui contient la valeur 70) dont la balance est supérieure à 1
2.b.Fonction TypeAB (R : * Tnoeud) : entier 2.c. Fonction Inserer (R:*Tnoeud, x: entier) : *
Tnoeud
InitPile(P) Si R =Nil alors
AVLvrai Retourner (CreerNoeud(x))
Sinon
TQ (R≠Null) ou (non PileVide(P)) faire
Si Info(R)>x alors
 TQ (R≠Null) T  Inserer(FG(R), x)
Si (Info (R) >= info (FD(R)) ou ((Info Aff_FG(R,T) ; Aff_Pere (T, R)
(R) < info (FG(R))) alors Retourner (R)
retourner(0) Sinon
Sinon T  Inserer(FD(R), x))
Aff_FD(R, T) ; Aff_pere (T, R)
B Profondeur (FR(R)) –
Profondeur (FD(R)) Retourner (R)
Fin
Si B >1 ou B < -1 alors AVL faux
Empiler (P, R)
R FG(R)
FTQ
Depiler (P, R)
R FD(R)
FTQ
Si AVL = vrai alors retourner (2)
Sinon retourner (1)
2.d. Fonction RechMaxNiv (R : * Maillon, niv : 2.d. Fonction RechMaxNiv (R : * Maillon, niv :
entier positif) : * Maillon entier positif) : * Maillon
Solution la plus simple : version itérative avec Solution récursive
parcours en largeur où on doit enfiler le nœud et Fonction RechMaxNiv(R : * Maillon, niv : entier
son niveau positif) : * Maillon
Structure Type 1 = enregistrement Si R = Nil alors retourner (Nil)
{ Sinon
@ : * Maillon Si (niv = 0) alors retourner (R)
Niv : entier Sinon
} Si FD (R) ≠ Nil alors retourner (FD(R), niv--)
Fonction RechMaxNiv(R : * Maillon, niv : entier Si FG (R) ≠ Nil alors retourner (FG(R), niv--)
positif) : * Maillon
Var : F : File d’attente, v : Type 1
Début
Si niv = 0 alors retourner (R)
Sinon
DSI
InitFile (F)
Si R ≠ Nil alors
DSI
v. @ R
v.@ 0
Enfiler (F, v)
TQ non filevide (F) faire
DTQ
Defiler (F, v)
 Si v.niv = niv alors retourner
(v.@)
Sinon
DSINON
v.niv++
SI FD (v.@) ≠ Nil alors
v.@  FD (v.@);
enfiler (F, v)
SI FG (v.@) ≠ Nil alors
v.@  FG (v.@);
enfiler (F, v)
FSINON
FTQ
FSI
FSI
Retourner (Nil)
Fin

3.a déroulement

3.b. transformer l’arbre en liste trié d’ordre décroissant