Exercices corrigés Arbre de décision - Ensiwiki

Exercices corrig´es
Arbre de d´ecision
Les arbres de d´ecisions permettent de caract´eriser une classe d’algorithmes de tris : les algos de tris par
comparaisons s´equentiels et d´eterministes. Cela correspond grosso-modo aux programmes de tri qu’on peut
´ecrire dans les langages imp´eratifs standard comme Ada, et en ne faisant que l’hypoth`ese d’une fonction de
pr´eordre <sur les ´el´ements `a trier.
Plus pr´ecis´ement, un algorithme donn´e correspond `a un ensemble d’arbres de d´ecision, dans lequel chaque
arbre de d´ecision repr´esente les suites de comparaisons effectu´ees par l’algorithme lorsque la s´equence en
entr´ee a une taille fix´ee n.´ Etant donn´e le caract`ere s´equentiel et d´eterministe des algos consid´er´es, ces suites
ont une structure d’arbre.
D´efinition 1 (Arbre de d´ecision).Soit Σun ensemble fini `a n´el´ements appel´e alphabet. Un arbre de
d´ecision sur Σ est un arbre binaire, dont :
– chaque nœud interne est ´etiquet´e “a?b” avec aet bdans Σ; un tel nœud repr´esente une comparaison
effectu´ee par l’algorithme entre deux ´el´ements de nom aet bdans la s´equence d’entr´ee.
– chaque feuille est ´etiquet´ee
– soit par une permutation des ´el´ements de Σ, qu’on note ha1, a2, . . . , anipour signifier a1< a2, etc.
(cette permutation correspond donc `a la permutation appliqu´ee par l’algorithme pour trier la s´equence
en entr´ee.)
– soit ´etiquet´ee par un symbole sp´ecial ⊥qui repr´esente du code de l’algorithme qui n’est jamais
ex´ecut´e. 1
Pour une s´equence d’entr´ee donn´ee (qui associe `a chaque ´el´ement de Σ une valeur concr`ete), l’ex´ecution
de l’algorithme de tri repr´esent´e par l’arbre de d´ecision, doit correspondre exactement `a un chemin entre la
racine et une feuille-permutation dans l’arbre. La figure 1 illustre par exemple le d´eroulement d’un 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.
Figure 1 – Arbre de d´ecision sur Σ = {a, b, c}pour un algorithme de tri par insertion.
1. On peut donc ainsi repr´esenter des algorithmes qui font des tests superflus.
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercices corrig´es

type Sequence i s array (Positive range <>) of Element ;
procedure TriInsertionSenti(T: in out Sequence) i s
-- version du tri par inse rti on avec se ntine lle :
-- on remplac e des compar ai son s sur les in dice s
-- par u ne com par aiso n au m ax imum ( la s en tin elle ).
I: Integer; E: Element ;
Fini : Bo olean := True ;
begin
-- on place le max en fin
for Kin T ’ F irst ..T ’ Las t - 1 loop
i f T (K +1) < T(K ) then
Fini := False ;
E := T ( K) ;
T (K) := T( K +1) ;
T (K +1) := E ;
end i f ;
end loop ;
i f Fini then
return ;
end i f ;
-- ici : T ’ Last > T ’ First et T ( T ’ Last ) est le max de T.
for Kin reverse T ’ First .. T ’ Last -2 loop
E := T( K );
I := K +1 ;
while T( I ) < E loop
T (I -1) := T (I );
I := I +1 ;
end loop ;
T(I -1) := E;
end loop ;
end ;
Figure 2 – Tri par insertion avec sentinelle.
Exercice 1. Calculer l’arbre de d´ecision sur Σ = {A, B, C}associ´e `a l’algorithme de tri donn´e en figure 2.
D´emonstration. Voil`a l’arbre de d´ecision sous forme textuelle :
si B<A alors
| si C<A alors
| | si C<B alors
| | | si A<B alors
| | | | absurde
| | | sinon (A>B)
| | | | tri=[C;B;A]
| | sinon (C>B)
| | | tri=[B;C;A]
| sinon (C>A)
| | si A<B alors
| | | absurde
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercices corrig´es

| | sinon (A>B)
| | | tri=[B;A;C]
sinon (B>A)
| si C<B alors
| | si C<A alors
| | | si B<A alors
| | | | absurde
| | | sinon (B>A)
| | | | tri=[C;A;B]
| | sinon (C>A)
| | | tri=[A;C;B]
| sinon (C>B)
| | tri=[A;B;C]
Sur cet algo, certains tests apparaissent superflus dans l’arbre de d´ecision (mais pas dans l’algo lui-mˆeme) :
cela vient du fait que dans l’arbre de d´ecision, on raisonne avec nfix´e, alors que dans l’algo, on raisonne avec
nquelconque.
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercices corrig´es

type Tab i s array (1.. n) o f Integer;
type Noeud ;
type Arb re De cisio n i s acce ss Noeud ;
type Noeud ( Est Feuille : Boolean ) i s record
case EstF euill e i s
when True =>
Per mutat ion : Tab ;
when others =>
Indice1 , Indice 2 : Integer ;
FGauche , FDr oit : Arb re De cisio n ; -- vaut null si cas i mpo ssibl e
end case ;
end record ;
Figure 3 – Structure Ada d’un arbre de d´ecision.
Exercice 2. Soit Tun tableau contenant `a n´el´ements. Pour coder un arbre de d´ecision associ´e `a un certain
algorithme de tri sur T, on utilise un type Noeud avec un champ bool´een EstFeuille indiquant si le nœud est
une feuille ou non. En Ada (voir figure 3), on fait de ce champ un discriminant. Ansi, si EstFeuille vaut
False, alors le nœud a les autres champs suivants :
–Indice1 et Indice2 correspondant au test T(Indice1) < T(Indice2).
–FGauche et FDroit correspondant aux 2 fils. Dans ces fils, une feuille ⊥est simplement repr´esent´ee par
un pointeur null.
Au contraire, si EstFeuille vaut True, alors le nœud repr´esente une permutation qui est donn´ee par son
champ Permutation. Celle-ci associe `a chaque position dans le tableau final (tri´e) sa position initiale dans T.
Ecrire une fonction Execute qui parcourt un arbre de d´ecision (suppos´e construit) Aet renvoie le tableau tri´e
correspondant aux valeurs stock´ees dans T.
function Execute ( A : in A rbr eDec isio n ; T : Tab ) return Tab ;
D´emonstration. On s´electionne la branche de Aen fonction des valeurs de T, puis on compose Tavec la
permutation trouv´ee.
function Execute (A: A rbreD ecisi on ; T : Tab ) return Tab i s
Res : Tab ;
Cour : A rbre Deci sion := A;
begin
while not Cour . Es tFeui lle loop
i f T [ Cour . In dice1 ] < T[ Cour . Indi ce2 ] then
Cour := Cour . FGauc he ;
e l s e
Cour := Cour . FDroit ;
end i f ;
-- normalement , Cour /= null si A repres ent e un tri corr ect !
end loop ;
for Iin Res ’Range loop
Res (I ) := T( Cour . Perm utati on (I )) ;
end loop ;
return Res ;
end Execute;
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercices corrig´es

Exercice 3. Combien de feuilles doit au moins poss´eder l’arbre de d´ecision associ´e `a un algorithme de tri ?
En d´eduire que tout algorithme de tri d’un ensemble de n´el´ements n´ecessite Ω(nlog n)comparaisons dans
le cas le pire.
D´emonstration. Soit Al’arbre de d´ecision associ´e `a un algorithme de tri d’un ensemble de n´el´ements. En
supposant que cet algorithme est correct, chacunes des n! permutations `a n´el´ements doit figurer sur une
feuille de A(sinon, l’inverse d’une permutation absente donne un ordre initial sur les ´el´ements pour lequel
l’algorithme ne trie pas le tableau correctement). Le nombre fde feuilles possibles de Av´erifie donc n!≤f.
n!≤f(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. Comme Aest un arbre binaire, on peut d´emontrer par r´ecurrence
que :
f≤2h(2)
En combinant les formules (1) et (2), on obtient
log2(n!) ≤h. (3)
La formule bien connue de Stirling nous donne une approximation 2de 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).
Exercice 4. ´ Ecrire un programme Ada qui construit automatiquement l’arbre de d´ecision associ´e `a un
programme de tri.
D´emonstration. Voir solution sur le wiki.
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.
2. Alternativement, si on ne se souvient plus par cœur de Stirling, on peut aussi transformer “log2(n!)” en “ 1
ln 2 Pn
i=1 ln i”
et majorer cette derni`ere somme par une int´egrale (la fonction ln s’int`egre par partie tr`es facilement)
Grenoble-INP Ensimag, 1`ere ann´ee, 2010-2011 Algo 2 — Exercices corrig´es