Introduction aux Arbres equilibres

Rappels sur les Graphes et arbres

Graphes
Un graphe oriente G est represente par un couple (S,
A) ou S est un ensemble fini et A une relation binaire
sur S tel que :
S = (ensemble des Si tel que Si est un sommet de G)
A = (ensemble des couples (Si, Sj) tel que que Si est
en « relation » avec Sj)
Exemple : Soit le graphe oriente G = (S, A) avec
l’ensemble de sommets S = {1, 2, 3, 4, 5, 6} et
l’ensemble d’arcs A = {(1, 2), (2, 2), (2, 4), (2, 5), (4,
1), (4, 5), (5, 4), (6,3)} ;
Parcours des graphes
a- Parcours en profondeur
Principe : developper l'arbre d'exploration du graphe
en privilegiant le premier successeur
procedure profondeur (G:graphe, s:sommet)
{
si non Marque(s) alors
{ marquer(s)
pour tout sommet j adjacent (voisin) de s faire
profondeur(G,j)
fpour }
}
Exercice : Ecrire une version du parcours en
profondeur sans recursivite

b- Parcours en Largeur
Principe : Developper d'abord les voisins d'un sommet
avant de continuer en profondeur

Procedure Largeur (G:graphe, s:sommet)

{
file f; enfiler(s); sommet s;
tant que non vide(file) faire
{
s=defiler(f);
si non marque(s) alors
{ marquer(s)
pour tout sommet j voisin(adjacent) de s faire
enfiler(f,j) fpour
}
}
}
Les Arbres

Theoreme (Proprietes des arbres). Soit G = (S, A) un

graphe . Les affirmations suivantes sont
equivalentes.
1.G est un arbre.
2.Deux sommets quelconques de G sont relies par
un unique chaine elementaire.
2.G est connexe et |A| = |S| − 1.
3.G est acyclique et |A| = |S| − 1.
4.G est acyclique, mais si une arete quelconque est
ajoutee a A, le graphe resultant contient un cycle.

Arbres binaires
Les arbres binaires se decrivent plus aisement de
maniere recursive. Un arbre binaire T est une structure
definie sur un ensemble fini de nœuds et qui pour
chaque nœud est forme de trois ensembles disjoints de
nœuds :
. une racine,
. un arbre binaire (appele son sous-arbre gauche)
. un arbre binaire (appele son sous-arbre droit).

Remarque : Dans un arbre binaire complet chaque

nœud est soit une feuille, soit de degre deux.
Arbres de recherche et arbres de recherche
equilibres

Definition (Arbre binaire de recherche).

Un arbre binaire de recherche est un arbre binaire
verifiant la propriete suivante : soient x et y deux
nœuds de l’arbre, si y est un nœud du sous-arbre
gauche de x, alors clef (y) < clef (x), si y est un nœud
du sous-arbre droit de x, alors clef (y) ≥ clef (x).

13
9
7 11 14
6 12 15
Arbre binaire de recherche

13
9
7 11 14
6 12 15
Ce n'est pas un arbre binaire de recherche
Recherche d'un element dans un arbre binaire
quelconque
boolean recherche (arbre A, element a rechercher x)
{
si vide(A) alors retourner faux
sinon si valeur(A)=x alors retourner vrai
sinon
si recherche(Droit(A),x) retourner vrai
sinon retourner recherche (Gauche(A), x)
}

Recherche d'un element dans un arbre binaire de

recherche
boolean recherche (arbre A, element a rechercher x)
{
si vide(A) alors retourner faux
sinon si valeur(A)=x alors retourner vrai
sinon si valeur(A) < x alors retourner
recherche(Droit(A),x) sinon
retourner recherche (Gauche(A), x)
}
Insertion d'un element dans un arbre binaire de
recherche.
L’element a ajouter est insere la ou on l’aurait trouve
s’il avait ete present dans l’arbre. L’algorithme
d’insertion recherche donc l’element dans l’arbre et,
quand il aboutit a la conclusion que l’element
n’appartient pas a l’arbre (l’algorithme aboutit sur un
nœud vide), il insere l’element comme fils du dernier
nœud visite (noeud pere du neoud a inserer).
Ce noeud pere est tel que :
valeur(pere) <=element_a_inserer et
droit(pere)=vide ou bien
valeur(pere)>element_a_inserer et
gauche(pere)=vide

En d'autres termes, le noeud pere est toujours au bout

d'une filliation: c'est soit une feuille, soit un noeud qui
n'a qu'un seul sous arbre.
Exemple : insertion de 27

Avant insertion
50
30
25 35 70
60 80

Apres insertion
50
30
25 35 70
60 80
27

procedure creer_feuille(arbre feuille, element e)

{
feuille=nouveau(Arbre) ; //creation d'un pointeur
feuille->info=e ;
feuille->droit=Null ;
feuille->gauche=Null;
}
Procedure inserer (arbre A, element e)
{
si vide(A) alors
creerfeuille(x,A) // creer un noeud de valeur x
sinon si x>=valeur(A) alors
inserer(droit(A), x)
sinon
inserer(gauche(A),x)
}

Exercices :

. Utiliser la procedure d'insertion dans un arbre

binaire de recherche afin de trier un vecteur par
ordre croissant.

. Ecrire une fonction recursive qui permet de calculer

le nombre de nœuds d'un arbre binaire

. Ecrire une fonction recursive qui permet de calculer

le nombre de feuilles d'un arbre binaire

. Ecrire une fonction recursive qui permet de calculer

la hauteur d'un arbre binaire.
Introduction aux arbres equilibres

Complexite
Si h est la hauteur de l’arbre , on peut aisement
montrer que tous les algorithmes precedents ont une
complexite en O(h). Malheureusement, un arbre
binaire quelconque a n nœuds a une hauteur comprise,
en ordre de grandeur, entre log2 n et n. L'arbre de
recherche « ideal » pour lequel une recherche
necessite au pire log2n comparaisons est un arbre
equilibre : (pour chaque noeud x, les sous arbres
gauche et droit de x ont sensiblement meme hauteur)

Exercice :Montrer par recurence que la hauteur d'un

arbre binaire complet est de :

h=log2(n) ou n est le nombre de nœuds de l'arbre

Les rotations

Rotation Droite

q p

p w devient u q

u v v w

Rotation Gauche

p q

u q devient p w

v w u v
Rotation Gauche-Droite

r q
p w p r

t q devient t u v w

u v

Rotation Droite_Gauche

r q

t p devient r p

q w t u v w

u v
Algorithmes des 4 rotations.

// Rotation Gauche
procedure RG(arbre a)
{
arbre b ;
b=a->droit ;
a->droit=b->gauche ;
b->gauche=a ;
a=b ;
}

// Rotation Droite
procedure RD(arbre a)
{
arbre b ;
b=a->gauche ;
a->gauche=b->droit ;
b->droit=a ;
a=b ;
}

// Rotation Gauche-Droite
procedure RGD(arbre a)
{
RG(a->gauche) ;
RD(a) ;
}
// Rotation droite_Gauche
procedure RDG(arbre a)
{
RD(a->droit) ;
RG(a) ;
}
Les Arbres AVL

Les arbres AVL sont des arbres binaires de recherche

equilibres definis de tel sorte que les hauteurs des sous
arbres gauches et droits de chaque nœud different d'au
plus une unité.

Avec une telle condition, on est assure que toute mise

a jour (insertion ou suppression) l'operation est
effectuee en o(log2(n)).

Exemples
12

8 16 C'est un arbre AVL

4 10 14

2 6
12

8 16 Ce n'est pas un arbre AVL

4 10 14 Les nœuds 8 et 12 violent la

condition
2 6

1
Principe d'insertion dans un arbre AVL

But : Apres insertion, effectuer la rotation appropriee

afin de maintenir l'arbre toujours AVL (equilibre).

L'operation de rotation n'est pas « couteuse » en

terme de complexite d'algorithme.
algorithme_insertion_dans_un_arbre_AVL
{
. Inserer un nouvel element au bon endroit (voir
algorithme d'insertion dans un arbre binaire de
recherche)
// reequilibrer l'arbre avec la rotation appropriee
. Debut du processus depuis la racine de l'arbre
. Soit N le nœud courant
. Soit Ng le nœud racine du sous arbre gauche de N
. Soit Nd le nœud racine du sous arbre droit de N
. Soient Ngg et Ngd les fils gauche et droit de Ng
. Soient Ndg et Ndd les fils gauche et droit de Nd

Si Abs(h(Ng)-h(Nd) > 1 // arbre non equilibres

{
Si h(Ng-h(Nd)==2 // desequilibre a gauche
{
Si h(Ngg)>h(Ngd) alors RD(N)
sinon RG(Ng) puis RD(N)
}

Sinon
{
Si h(Ndd)>h(Ndg) alors RG(N)
sinon RD(Nd) puis RG(N)
}
}
}
Exercice : Construire l'arbre AVL correspondant a
l'insertion des elements suivants dans l'ordre.

2, 10, 12, 4, 16, 8, 6, 14

Remarque : pensez a etiqueter les nœuds de l'arbre

apres chaque insertion et rotation de la façon
suivante :

0: si les deux sous arbres sont de meme hauteur

+n : si le s/arbre gauche est plus profond avec une
diffrence de n
-n : si le s/arbre droit est plus profond avec une
diffrence de n