Ecole Supérieure en Sciences et Technologies de l’Informatique et du Numérique 2022/2023

Algorithmique 2 1ère année Classe Préparatoire

Corrigé type Examen ASDD

Exercice 1 :
1. S={11, 15, 5, 2, 3, 9, 17, 21, 22, 13, 19, 4, 12}, l’arbre binaire de recherche obtenu est le
suivant :

2. Taille= 13
Profondeur = 4
Nœuds internes : 11, 5, 15, 2, 3, 13, 17, 21
Nœuds externes : 4, 9, 12, 19, 22
Parcours post-ordre : 4- 3- 2- 9- 5- 12- 13- 19- 22- 21- 17- 15- 11
3. Transformation en forêt

4. Affichage de valeurs d’une façon décroissante

Type Nœud = structure
Inf : entier
Fg, Fd:↑(Nœud)
Fin structure
Arbre = ↑(Nœud)
Var A : Arbre

Page 1
 Procédure AffDecr (A: Arbre)
Début
Si (A <> Nil) alors
AffDecr (Fd(A))
Ecrire(Info(A))
AffDecr (Fg(A))
Fin Si
Fin
5. Fonction qui calcule nombre de feuilles
Fonction Nbr_Feuilles (A: Arbre) : Entier
Début
Si (A = Nil) alors
Retourner 0
Sinon
Si (Fg(A)=Nil) et (Fd(A)=Nil) Alors
Retourner 1
Sinon

Retourner Nbr_Feuilles(Fg(A)) + Nbr_Feuilles(Fd(A))

Fin Si
Fin Si
Fin
6. Fonction qui calcule la profondeur d’un arbre
Fonction Profondeur (A: Arbre) : Entier
Début
Si (A = Nil) alors
Retourner 0
Sinon
Retourner 1 + Max (Profondeur (Fg(A)), Profondeur (Fd(A)))
Fin Si
Fin
7. Procédure Preordre itérative avec les piles :
Element= structure
val: Arbre
suiv: Pointeur(Element)
Fin structure
pile = structure
sommet: Pointeur(Element);
Fin structure
Procédure AffichePreordre (A: Arbre)
Var P : Pile
Début
CréerPile(P)
Si (A ≠ Nil) alors
Empiler(P, A)
Tant que Non(PileVide(P)) Faire
Dépiler(P, A)
Ecrire(Info(A))
Si (Fd(A) ≠ Nil) alors
Empiler(P, Fd(A))
Fin Si
Si (Fg(A) ≠ Nil) alors
Empiler(P, Fg(A))
Fin Si

Page 2
 Fin Tantque
Fin Si
Fin
8. Ordre de grandeur est O(n) car on doit parcourir tous les nœuds de l’arbre.
Exercice 2 :
1. Une fonction récursive qui calcule la somme de deux entiers positifs a et b :
Fonction Somme (a, b: entier) : entier
Début
Si (a = 0) alors
Somme  b
Sinon
Somme  Somme (a-1, b+1) ;
Fin Si
Fin
2. Type de récursivité : Simple et terminale
3. Généralisation de la fonction aux entiers de signe quelconque :
Fonction Somme (a, b: entier) : entier
Début
Si (a = 0) alors
Somme  b
Sinon
Si (a > 0) alors
Somme  Somme (a-1, b+1)
Sinon
Somme  Somme (a+1, b-1)
Fin Si ;
Fin Si ;
Fin ;

Exercice 3 :
1. Procédure distribuer(var joueurA: FileCarte, var joueurB: FileCarte, var C:PileCarte)
var t: Carte;
Début
creer_file(joueurA);
creer_file(joueurB);
Tant que non pile_vide(C) faire
depiler(C, t)
enfiler(joueurA, t)
depiler(C, t)
enfiler(joueurB, t)
Fin tantque;
Fin

Page 3
 2. Procédure jouerCoup(var joueurA: FileCarte, var joueurB: FileCarte);
var B: bataille; a, b: Carte;
Début
defiler(joueurA, a);
defiler(joueurB, b);

Si (a.id > b.id) alors

emfiler(joueurA, a);
emfiler(joueurA, b);
Sinon
Si(b.id > a.id) alors
enfiler(joueurB, a);
enfiler(joueurB, b);
Sinon
// lancer une bataille
creer_pile(B.joueur1);
creer_pile(B.joueur2);
empiler(B.joueur1, a);
empiler(B.joueur2, b);
Tantque (a.id =b.id) faire
defiler(joueurA, a);
defiler(joueurB, b);
empiler(B.joueur1, a);
empiler(B.joueur2, b);
Fin tantque;
Si (a.id>b.id) alors
emfilerBataille(joueurA,B);
Sinon
emfilerBataille(joueurA,B);
FinSi;
FinSi;
FinSi;
Fin;
3. Procédure jouer (var C:PileCarte);
var joueurA, joueurB: FileCarte;
Début
destribuer(joueurA, joueurB, C);
Tant que (non file_vide(joueurA) et non file_vide(joueurA)) faire
jouerCoup(joueurA, joueurB);
Fin tantque;
si (file_vide(joueurA) ) alors
Ecrire (" le joueur B a gagné");
sinon
Ecrire (" le joueur A a gagné");
Fin si;
Fin;

Page 4