tp4-arbres-binaires-tas

T.P. 4 : des arbres binaires vari´es et leurs applications
1 Arbres binaires de recherche
1.1 Ce qu’on doit d´ej`a savoir sur la recherche d’un mot dans une liste
tri´ee et apr`es ...
Supposons par exemple qu’on veuille constituer et manipuler un lexique anglais/fran¸cais. Un
tel lexique sera repr´esent´e en Python par une liste de couples de mots, comme par exemple :
lexique = [(’blue’,’bleu’),(’green’,’vert’),(’red’,’rouge’),(’yellow’,’jaune’)]
On suppose que les mots anglais sont rang´es dans l’ordre du dictionnaire (comme dans l’exemple
pr´ec´edent). Cet ordre est l’ordre implant´e en python sur les chaines de caract`eres avec le symbole <.
Notons aussi que pour les couples, python commence par comparer les premi`eres entr´ees.
On suppose donc qu’on dispose d’une variable globale lexique comme ci-dessus.
a) Sachant que la liste des mots anglais est tri´ee dans l’ordre du dictionnaire, ´ecrire une fonction
traduit qui re¸coit un mot anglais en argument (qui est suppos´e ˆetre dans le lexique) et
renvoie sa traduction avec une complexit´e en O(log(n)) o`u nest la longueur du lexique.
N.B. La complexit´e logarithmique demande une m´ethode de dichotomie.
b) Ecriture une fonction insere qui re¸coit un argument qui est un couple (motanglais,
motfrancais) qui permet de rajouter ce couple `a la bonne place dans la variable globale
lexique : cette fonction sera de complexit´e lin´eaire.
Le probl`eme : la repr´esentation de notre lexique sous cette forme fait que la fonction insere a
une complexit´e en O(n). Nous allons maintenant pr´esenter une nouvelle fa¸con de coder le lexique,
une autre structure de donn´ee, o`u l’insertion, comme la recherche, d’un mot dans le lexique, sera
en O(log(n)).
1.2 Pr´esentation des arbres binaires de recherche
D´efinition math´ematique 1 : un arbre sera pour nous un ensemble de points appel´es noeuds
muni d’une relation pour laquelle chaque noeud a un p`ere et un seul (on repr´esente la relation
p`ere fils par une fl`eche), sauf un noeud qui n’a pas de p`ere qu’on appelle la racine. On convient de
repr´esenter la racine en haut et les p`eres en dessus de leurs fils.
Si le noeud pest le p`ere du noeud fon dit aussi que fest un fils de p. Les noeuds qui n’ont
pas de fils sont appel´es feuilles.
D´efinition math´ematique 2 : un arbre au sens pr´ec´edent sera dit arbre binaire si chaque p`ere
a au plus deux fils, appel´es alors fils droit et fils gauche.
Lien avec notre probl`eme : Chaque noeud sera un ´el´ement de notre ensemble de couples
(motanglais,motfrancais). La relation p`ere/fils entre les mots sera d´efinie au niveau des parties
motanglais (la partie motanglais du couple est ce qu’on appelle la cl´e d’enregistrement).
1

Par exemple, avec un lexique `a quatre mots :
ici la racine sera le couple dont blue est la cl´e, avec deux fils de cl´es red et yellow et red a un fils
green
D´efinition 3 : d´efinition informatique d’un arbre binaire, avec son implantation py-
thon : un arbre binaire est une structure de donn´ee qui peut ˆetre d´efinie r´ecursivement comme
suit : un arbre binaire est :
— soit vide, cod´e comme une liste vide [],
— soit cod´e comme une liste [racine, filsGauche, filsDroit] o`u racine est un couple
(motanglais,motfrancais), et filsDroits et filsGauche sont deux arbres binaires.
Exemple : Avec Arbrelexique=[(’blue’,’bleu’),filsGauche,filsDroit] o`u
filsGauche=[(’red’,’rouge’),[],[(’green’,’vert’),[],[]]] et
filsDroit=[(’yellow’,’jaune’),[],[]], on aura le codage informatique de l’arbre binaire
dessin´e ci-dessus.
D´efinition 4 : arbre binaire de recherche :un arbre [racine, filsGauche, filsDroit] au
sens de la d´efinition 3 est un arbre binaire de recherche si, et seulement si,
— la cl´e de racine est strictement sup´erieure `a la cl´e de tous les noeuds de filsGauche,
— la cl´e de racine est strictement inf´erieure `a la cl´e de tous les noeuds de filsDroit,
—filsDroit et filsGauche sont des arbres binaires de recherche.
L’exemple pr´ec´edent ne donne pas un arbre binaire de recherche mais la version modifi´ee sui-
vante oui :
1.3 Implantation en python de la fabrication r´ecursive des arbres bi-
naires de recherche... et recherche !
On consid`ere donc des arbres binaires de recherche comme d´efinis au paragraphe pr´ec´edents,
dont les noeuds sont des couples (motanglais,motfrancais) que l’on compare pour l’ordre lexi-
cographique des mots anglais.
a) Ecrire trois fonctions filsGauche, filsDroit, racine qui prennent en argument un arbre
binaire de recherche arbre et renvoie respectivement son fils Gauche, son fils Droit, et sa
racine.
2

b) On veut ´ecrire alors une fonction r´ecursive ajout(element, arbre) qui prend comme ar-
gument un ´el´ement i.e. un couple (motanglais,motfrancais) et un arbre binaire (qui au
d´epart peut ˆetre vide, ce sera notre cas de base) et qui retourne un nouvel arbre binaire de
recherche o`u element est incorpor´e `a arbre.
N.B. on doit comparer les mots anglais.
Pour cela, le principe est le suivant :
●si le mot anglais de l’´el´ement `a rajouter est plus grand que le mot anglais `a la racine de
l’arbre, on construit un arbre binaire en gardant la mˆeme racine, le mˆeme fils gauche, et on
se ram`ene au probl`eme de rajouter l’´el´ement au fils droit.
●si le mot anglais de l’´el´ement `a rajouter est plus petit que le mot anglais `a la racine de
l’arbre ... `a vous de deviner !
Ecrire la fonction python correspondante ! Par commodit´e pour la suite, on consid´erera aussi
le cas o`u le mot qu’on rajoute est d´ej`a pr´esent dans l’arbre : dans ce cas bien sˆur l’arbre ne
devra pas ˆetre modifi´e.
c) Appliquer la fonction pr´ec´edente pour fabriquer un arbre binaire de recherche pour notre
lexique en ajoutant successivement les ´el´ements de la liste suivante :
lexique = [(’red’,’rouge’),(’blue’,’bleu’),(’yellow’,’jaune’),(’green’,’vert’)]
d) Ecrire enfin une fonction r´ecursive traduit2(mot,arbre) qui renvoie la traduction d’un
mot anglais qui est stock´e dans un arbre binaire de recherche comme pr´ec´edemment.
(On comparera mot `a la (partie anglaise de la) racine de l’arbre, et si ils sont diff´erents,
ensuite r´ecursivement soit `a filsDroit soit `a filsGauche..)
1.4 Complexit´es : arbres ´equilibr´es
a) D´efinition : la hauteur (on dit aussi profondeur) d’un noeud de l’arbre est le nombre de
g´en´erations qui le s´eparent de la racine de l’arbre. Cette hauteur admet naturellement une
d´efinition r´ecursive rigoureuse (laquelle ?)
En d´eduire une fonction r´ecursive hauteur(element, arbre) qui renvoie la hauteur du
noeud element suppos´e pr´esent dans l’arbre arbre.
b) Par d´efinition la hauteur de l’arbre est la maximum des hauteurs des ´el´ements. On dira
qu’un arbre ayant nnoeuds est ´equilibr´e ssi sa hauteur est minimale parmi tous les arbres
ayant nnoeuds. Donner en l’expliquant, une relation entre la hauteur hd’un arbre ´equilibr´e
et son nombre total de noeuds n.
Le dessin suivant, qui est un cas particulier devrait suffire pour comprendre !
N.B. Pour les questions qui suivent, on admet qu’on peut toujours ranger nos donn´ees dans
un arbre binaire de recherche ´equilibr´e 1.
c) Justifiez que la fonction traduit2 du paragraphe pr´ec´edent, appliqu´ee `a un arbre ´equilibr´e,
est de complexit´e O(log(n)) o`u nest le nombre de noeuds de l’arbre.
d) La fonction ajout du paragraphe pr´ec´edent fabrique-t-elle forc´ement des graphes ´equilibr´es ?
e) Montrer en tous cas que si on applique cette fonction ajout a un arbre ´equilibr´e ayant n
noeuds, la complexit´e de l’ajout est en O(log(n)).
1. en fait il existe bien des algorithmes pour s’y ramener, en faisant des rotations
3

Moralit´e : par rapport `a ce qu’on a dit au tout premier paragraphe, les arbres binaires de
recherche ´equilibr´es ont l’avantage qu’aussi bien la recherche que l’ajout d’une donn´ee sont en
O(log(n)).
2 Une classe python fabriqu´ee suivant les principes du §1 :
les dictionnaires python
La classe dictionary n’est pas au programme, dans une ´epreuve d’´ecrit on devrait vous la pr´esenter !
a) Au §1, on a expliqu´e (modulo le probl`eme d’´equilibrage des arbres !) comment fabriquer une
structure qui permet de g´erer un dictionnaire de nmots avec une complexit´e en O(log(n)) pour la
recherche et l’ajout d’un mot. En python, il existe une structure qui fait exactement cela, la classe
dict.
Par exemple dico={’red’: ’rouge’, ’blue’: ’bleu’, ’yellow’ : ’jaune’}sera un dic-
tionnaire avec trois entr´ees, les mots en anglais ici seront les cl´es qui servent `a acc´eder aux valeurs
qu’elles r´ef´erencent (ici les mots en fran¸cais).
Voici quelques commandes de cette classe :
a={} # cr´eation d’un dictionnaire vide appel´e a
a[’truc’]=12 # cr´eation d’une entr´ee du dictionnaire avec la valeur 12 et `a la cl´e ’truc’
# eh oui c’est exactement ce qu’on ne peut pas faire avec les listes.. pas de out of range ici !
a[’truc’] # va renvoyer la valeur 12.
dico[’red’] # va renvoyer ’rouge’
’yellow’ in dico # va renvoyer True
’black’ in dico # va renvoyer False
Question (exemple) ´ecrire une fonction freq qui prend en param`etre une chaˆıne de ca-
ract`eres comme ’CABBAA’ et renvoie un dictionnaire o`u les lettres sont les cl´es et le nombre d’oc-
currence de chaque lettre est la valeur stock´ee pour chaque cl´es. Ainsi freq(’CABBAA’) renverra
{’A’: 3, ’B’: 2, ’C’: 1}. Noter qu’il n’y a pas d’ordre d´efini entre les cl´es d’un dictionnaire.
b) Quelque pr´ecision sur le parcours des dictionnaires :
(i) Avec dico comme ci-dessus, que donne le code :
for a in dico:
print(a)
(ii) Comment faire alors pour voir `a la fois les cl´es et les valeurs qu’elles r´ef´erencent dans
le dictionnaire dico ? Cr´eer une fonction ListeCouple qui prend en argument un dictionnaire et
renvoie une liste des couples (cl´e,valeur). Par exemple ListeCouple(dico) renverra (`a l’ordre
pr`es) :
[(’blue’, ’bleu’), (’red’, ’rouge’), (’yellow’, ’jaune’)]
3 Tri avec la construction d’un arbre binaire de recherche
On a vu au §1.3 comment on pouvait transformer une liste en arbre binaire de recherche.
Explicitement, `a l’aide de la fonction ajout d´efinie dans ce paragraphe, ´ecrire une fonction ABR qui
fabrique un tel arbre `a partir d’une liste. Ainsi pour L=[34,2,667,1,4,20],ABR(L) donnera :
[34, [2, [1, [], []], [4, [], [20, [], []]]], [667, [], []]]
Expliquer ce que fait alors la fonction suivante, appliqu´ee la variable arbre ci-dessus, et `a la
liste vide t=[] :
def parcoursProfondeur(arbre,t):
if arbre!=[]:
t=parcoursProfondeur(filsGauche(arbre),t)
4

t.append(racine(arbre))
t=parcoursProfondeur(filsDroit(arbre),t)
return t
En d´eduire une m´ethode pour trier une liste (par exemple une liste de nombres) qui commence
par transformer cette liste en arbre binaire de recherche.
4 Les tas et le tri par tas
4.1 La structure de tas : encore un arbre binaire
D´efinition : un tas binaire, ici on dira simplement un tas (en anglais heap) est un arbre binaire
(comme au §1) qui est ordonn´e de sorte que la cl´e d’un noeud est toujours sup´erieure `a la cl´e de
ses fils (de sorte que son plus grand ´el´ement est toujours la racine de l’arbre) 2.
Du point de vue informatique, on va ici coder simplement ces arbres par un tableau (liste
python) de nombres.
Par exemple T=[9,5,6,2,1,5,1,0] codera l’arbre ci-
contre. Cet arbre est bien un tas, puisque chaque p`ere a
une valeur sup´erieur `a celles de ses fils.
L’int´erˆet des tas pour les tris : Au §3, on a expliqu´e comment obtenir un algorithme de tri
en transformant une liste en arbre binaire de recherche. Ici c’est bien plus imm´ediat avec les tas
puisque si on sait ranger les donn´ees en un tas, `a chaque fois la premi`ere entr´ee donnera le max.
de la liste.
4.2 Organisation en tas
But de cette partie : prendre une liste quelconque et la r´eorganiser en un tas.
On va donc g´erer les tas `a l’aide de listes pythons : chaque liste python sera interpr´et´ee menta-
lement par nous comme associ´ee `a un arbre binaire (qui n’est pas forc´ement un tas). Par exemple
pour T=[5,2,6,0,1,9,1,5]
2. En fait, il s’agit de tas-max, en rempla¸cant sup´erieur par inf´erieur, on a la notion de tas-min.
5