ARBRES

Terminologie de base
• Définition
1- Un nœud unique, par lui-même, est un arbre. Il
est aussi racine de l’arbre.
2- Si n est un nœud et a1, a2, …, ak sont des arbres
de racines respectives n1, n2, …, nk, on peut
construire un nouvel arbre en associant un parent
unique aux nœuds n1, n2, …, nk, le nœud n.
Dans cet arbre, n est la racine et a1, a2, …, ak
sont les sous-arbres de cette racine. n1, n2, …, nk
sont appelés les fils voire les enfants de n.
3- L’arbre vide est un arbre sans nœud, noté Λ
Ordre sur les nœuds d’un
arbre
Les fils sont habituellement ordonnés
de gauche à droite.
Il arrive qu’un autre ordre soit
considéré, il faut alors qu’il soit
défini.
 Arbres binaires de
recherche (ABR)
• Structure de base
– Le sous arbre gauche (respectivement
droit) d’un nœud X ne contient que les
éléments inférieurs strictement
(respectivement supérieurs strictement)
à celle de l’élément contenu dans X
• Avantages
– Insertion, suppression, élément,
minimum en O(n)
 Parcours
• Infixé (Gauche Racine Droite)
• Préfixé (Racine Gauche Droite)
• Postfixé (Gauche Droite Racine)
 Structure de donnée

Typedef struct tree

{ int val;
struct tree *fg;
struct tree *fd;
} arbre;
 Opérations
• Créer un arbre constitué d’une seule
feuille
• Construire un nouvel arbre à partir
de deux sous arbres (un gauche et
un droit) et une valeur.
• Profondeur d’un arbre
• Taille d’un arbre
• Recherche d’un élément dans l’arbre
• Ajouter un élément dans l’arbre
• Supprimer un élément de l’arbre
A partir de là on suppose que les
éléments d’un ABR sont distincts,
c’est à dire que Le sous arbre
gauche (respectivement droit)
d’un nœud X ne contient que les
éléments inférieurs
(respectivement supérieurs) à
celle de l’élément contenu dans X
void creer_feuille (int el, arbre **bebe)
{
if (((*bebe)= (arbre *) malloc
(sizeof(arbre)))== NULL)
printf (‘’erreur allocation’’);
else
{ (*bebe)→ val =el;
(*bebe) → fg= NULL;
(*bebe) → fd=NULL;
}
}
void cons (int el, arbre *ag, arbre *ad, arbre **pepe)
/*on suppose que ag et ad sont des ABR et on suppose
que el est plus petit que le plus petit élément de ad
et qu’il est plus grand que le plus grand élément de
ag*/
{
if (((*pepe)=(arbre *)malloc (sizeof(arbre)))==NULL)
printf (‘’erreur allocation’’);
else
{ (*pepe)→ val=el;
(*pepe)→ fg=ag;
(*pepe)→ fd=ad;
}
}
int profondeur (arbre *ar)
{
int p1, p2;
if (ar==NULL)
return 0;
p1=profondeur (ar→ fg);
p2= profondeur (ar→ fd);
if (p1 > p2)
return 1+p1;
else return 1+p2;
}
int taille (arbre *ar)
{ int p1, p2;
if (ar==NULL)
return 0;
p1=taille (ar→ fg);
p2=taille (ar→ fd);
return 1+p1+p2;
}
int recherche (int el, arbre *ar)
{ if (ar==NULL)
return 0;
if (el== ar→ val)
return 1;
else if (el <ar→ val)
return recherche(el, ar→ fg);
else
return recherche (el, ar→ fd);
}
void ajouter(int el, arbre **arb)
/*Les éléments sont distincts */
{ arbre *nvl_ar, *ar;
ar=*arb;
if (ar==NULL)
{ (*arb) =(arbre *) malloc(sizeof(arbre));
(*arb)→ val=el; (*arb)→ fg=NULL;
(*arb)→ fd=NULL}
else while (TRUE)
{if (el==ar→ val)
break;
else if (el< ar→ val)
{if (ar→ fg==NULL)
{nvl_ar=(arbre *) malloc(sizeof(arbre));
nvl_ar→ val=el; nvl_ar→ fg=NULL;
nvl_ar→ fd=NULL; ar→ fg=nvl_ar; break;}
else ar=ar→ fg;
}
else {if (ar→ fd==NULL)
{nvl_ar=(arbre *) malloc(sizeof(arbre));
nvl_ar→ val=el; nvl_ar→ fg=NULL;
nvl_ar→ fd=NULL; ar→ fd=nvl_ar;
break;}
else ar=ar→ fd;}
}
}
 Suppression d’un élément
Plusieurs cas sont à considérer, une fois que le nœud à supprimer
a été trouvé à partir de sa clé :

 Suppression d'une feuille : Il suffit de l'enlever de l'arbre vu qu'elle n'a

pas de fils.
 Suppression d'un nœud avec un enfant : Il faut l'enlever de l'arbre en le
remplaçant par son fils.
 Suppression d'un nœud avec deux enfants :
Supposons que le nœud à supprimer soit appelé N
(le nœud de valeur 7 dans le graphique suivant).
On le remplace alors par son successeur le plus proche
(le nœud le plus à gauche du sous-arbre droit - ci-dessous,
le nœud de valeur 9) ou son plus proche prédécesseur
(le nœud le plus à droite du sous-arbre gauche, le nœud de valeur 6).
Cela permet de garder une structure d'arbre binaire de recherche.
Puis on applique à nouveau la procédure de suppression à N,
qui est maintenant une feuille ou un nœud avec un seul fils.
Suppression d’un élément
Dans tous les cas cette opération requiert
de parcourir l'arbre de la racine jusqu'à une
feuille : le temps d'exécution est donc
proportionnel à la profondeur de l'arbre qui
vaut n dans le pire des cas, d'où une
complexité maximale en O(n).