Exercice corrigé Arbre de décision - Ensiwiki

Exercice corrig´e
Arbre de d´ecision
Le tri d’un ensemble d’´el´ements (par exemple des entiers) peut ˆetre vu de mani`ere abstraite `a l’aide d’un
arbre de d´ecision. Un arbre de d´ecision est un arbre binaire repr´esentant les comparaisons entre ´el´ements lors
du tri. Chaque nœud interne de l’arbre correspond `a la comparaison de deux ´el´ements aet b, et on note ce
nœud a?b. Chaque feuille correspond `a un ordre, i.e. une permutation, sur les ´el´ements de l’ensemble, qu’on
note ha1, a2, . . . , anipour signifier a1< a2, etc. L’ex´ecution de l’algorithme de tri correspond `a un chemin
entre la racine et une feuille dans l’arbre de d´ecision. La figure 1 illustre par exemple le d´eroulement de
l’algorithme de tri par insertion sur un ensemble de trois ´el´ements {a, b, c}. Si on prend par exemple a= 27,
b= 42 et c= 5, l’algorithme va suivre le chemin surlign´e en rouge.
Fig. 1 – Arbre de d´ecision pour l’algorithme de tri par insertion sur trois ´el´ements a,bet c.
Exercice 1. Montrer qu’un arbre de d´ecision est forc´ement localement complet. En d´eduire que tout algo-
rithme de tri d’un ensemble de n´el´ements n´ecessite Ω(nlog n)comparaisons dans le cas le pire.
D´emonstration. Soit Aun arbre de d´ecision. Un nœud interne de Acorrespond `a la comparaison de deux
´el´ements aet b, et poss`ede donc forc´ement deux fils : soit a<b, soit a≥b.Aest donc bien localement
complet.
Soit Nle nombre total de nœuds de A:N=ni+f, avec ni et frespectivement le nombre de nœuds internes
et le nombre de feuilles de A. Comme Aest localement complet, on sait que f=ni + 1 (cette propri´et´e se
d´emontre par r´ecurrence sur ni). On a donc N= 2f−1.
Si Aest l’arbre de d´ecision d’un algorithme de tri d’un ensemble de n´el´ements, en supposant que cet
algorithme est correct, chaque feuille doit correspondre `a une permutation diff´erente de ces ´el´ements, et
toutes les permutations doivent ˆetre repr´esent´ees dans A. Comme il y a n! permutations possibles, on a
f=n!, et donc
N= 2n!−1.(1)
Remarquons `a pr´esent que le nombre de comparaisons dans le cas le pire correspond au nombre de nœuds
internes travers´es par le chemin le plus long allant de la racine `a une feuille de l’arbre de d´ecision. Autrement
dit, c’est exactement la hauteur hde l’arbre. Que vaut cette hauteur ? Par d´efinition d’un arbre binaire, on
a
N≤2h+1 −1 (2)
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercice corrig´e

(avec ´egalit´e si et seulement si l’arbre est complet).
En combinant les ´equations (1) et (2), on obtient
2n!≤2h+1
ou encore
log(n!) ≤h. (3)
La formule bien connue de Stirling nous donne une approximation de la factorielle de n :
n! = √2πn(n
e)n(1 + Θ( 1 n)).
On a donc :
∃A > 0, n!≥A(n
e)n
ce qui nous donne :
log(n!) ≥log A+nlog n−nlog e.
On peut v´erifier que
∀n≥e2, n log n−nlog e≥1
2nlog n.
Grˆace `a l’´equation (3), on a donc bien
∃B > 0,∃N0>0,∀n≥N0, h ≥Bn log n.
On a donc bien montr´e que le nombre de comparaisons dans le cas le pire est en Ω(nlog n).
Bibliographie indicative
[1] T. Cormen, C. Leiserson, R. Rivest, C. Klein. Introduction `a l’algorithmique : cours et exercices. Dunod,
2002.
Disponible `a la B.U. Sciences et `a la biblioth`eque MI2S, en fran¸cais et en anglais.
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercice corrig´e

Exercice 2. Soit Tun tableau contenant nentiers positifs ou nuls. Supposons que nous codons un arbre
de d´ecision, associ´e `a un certain algorithme de tri sur T, de la fa¸con suivante. Chaque nœud contient deux
entiers, correspondant aux deux indices des valeurs du tableau compar´ees dans le cas d’un nœud interne,
et ´egaux `a 0dans le cas d’une feuille. Il contient ´egalement un tableau de n´el´ements, correspondant `a la
permutation r´esultat dans le cas d’une feuille et contenant une unique valeur −1dans le cas d’un nœud
interne (on prend cette valeur car elle n’est pas pr´esente dans T). Ceci donne en Ada :
type Tab is array(1..n) of Integer;
type Noeud;
type ArbreDecision is access Noeud;
type Noeud is record
Indice1, Indice2 : Integer; -- vaut 0 si feuille
Permutation : Tab; -- vaut [-1,-1,...,-1] si noeud interne
Gauche, Droit : ArbreDecision; -- vaut null si feuille
end record;
Ecrire une fonction GetPermutation(T : in Tab, A : in ArbreDecision) return Tab ; qui parcourt un
arbre de d´ecision (suppos´e construit) Aet renvoie la permutation correspondant aux valeurs stock´ees dans T.
D´emonstration. L’algorithme sera bien sˆur r´ecursif. Le principe est le suivant : on part de la racine ; tant
qu’on est sur un nœud interne on compare T[Indice1] et T[Indice2], et on descend dans l’arbre en fonction
du r´esultat. Une fois arriv´e sur une feuille, il suffit de renvoyer le tableau Permutation.
function GetPermutation(T : in Tab, A : in ArbreDecision) return Tab is
begin
if (A.Indice1 == 0) then
-- on est sur une feuille
return A.Permutation;
end if;
-- sinon on est sur un noeud interne
if (A.T[A.Indice1] < A.T[A.Indice2]) then
-- on descend `a gauche
return GetPermutation(T,A.Gauche);
end if;
-- sinon on descend `a droite
return GetPermutation(T,A.Droit);
end GetPermutation;
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercice corrig´e