Université Hassan II – Casablanca

Faculté des Sciences et Techniques

– Mohammedia
Département Informatique

COMPTE RENDU

Fonctions de manipulation des arbres binaires

Réalisé par : Encadré par :

BOUMOUZOUNA BRAHIM VALL MR. A. BEKKHOUCHA
EL IDRISSI HAMZA
Module :
Structures des données
Parcours : Année universitaire :
ILISI 1 2021-2022

Page 1
 Table de Matière :

Introduction----------------------------------------------------------------------- 3
Analyse----------------------------------------------------------------------------- 4
Fonctions de manipulation : -------------------------------------------------- 7

Les fonctions communes des arbres binaires--------------------------- 7

Les fonctions des arbres binaires Ordonnés Horizontalement ----- 14

Les fonctions des arbres binaires quelconques------------------------- 16

Programme principale main( ): -------------------------------------------------- 20

Conclusion------------------------------------------------------------------------- 26

Page 2
 I. Introduction :
Dans ce compte rendu nous allons présenter quelques fonctions de manipulation des arbres
binaires, et nous allons focaliser sur les arbres binaires ordonnés horizontalement et les arbres
binaires quelconques. Mais d’abord c’est quoi un arbre en informatique ?

En informatique, un arbre est une structure de données non linaire qui peut se représenter sous
la forme d'une hiérarchie dont chaque élément est appelé nœud, le nœud initial étant
appelé racine. Dans un arbre, chaque élément possède 0 à n éléments fils au niveau inférieur, les
nœuds qui possèdent 0 fils sont appelés des feuilles. (Figure 1)
Un arbre binaire est un arbre dont chaque élément possède aux plus deux fils, habituellement
appelés gauche et droit. (Figure 2)
Un arbre binaire est ordonné horizontalement si la clé de tout nœud non feuille est supérieur à
toutes celles de son sous arbre gauche et inferieur a toutes celles de son sous arbre droit. (Figure 3)

Figure 1 – Arborescence de fichiers

Figure 2 – Expressions mathématiques : Figure 3 – arbre binaire ordonné horizontal

3 + 2*5 - 4 des entiers

Page 3
 II. Analyse :
1- Définition de la structure d’un arbre binaire :

#include <stdio.h>
#include <stdlib.h>
//structure d'un arbre à l'aide des pointeurs
typedef struct Ned
{
int info;//étiquette
struct Ned * left;//pointeur sur fils gauche
struct Ned * right;//pointeur sur fils droit
}Noeud;//structure noeud

2- Traitement sur les arbres binaires :

Le traitement sera effectué sur des arbres binaires dont leurs étiquettes sont des entiers pour
simplifier le traitement :

- Création et initialisation d’un nœud

La création se fait à l’aide d’une fonction similaire a celle des listes, où on fait une
allocation de la mémoire d’un pointeur de taille Nœud, on vérifie si l’allocation n’a pas
échoué puis on initialise les champs : info par une valeur passée en argument, les
pointeurs du fils gauche et droite par NULL et à la fin on retourne le nœud créé.

- Insertion d’un nœud dans un arbre

Pour un arbre binaire ordonné horizontalement l’insertion se fait d’une manière simple.
Si l’arbre ou le sous arbre est vide le nœud devient la racine, si non si l’étiquette du nœud
est plus petite que celle de la racine l’insertion se fait dans le sous arbre gauche si non
dans le sous arbre droit.

On insère la valeur 5

Pour un arbre binaire quelconque et comme le nom l’indique, y’a une infinité de
méthodes d’insertion. Dont nous allons introduire une, elle consiste à insérer dans le
champ du fils NULL et si le nœud a deux fils au préalable on refait la procédure dans le
sous arbre gauche ou le sous arbre droit, selon un caractère passé en argument ‘D’ : droit
ou ‘G’ : gauche.

On insère la valeur 3
Page 4
 - Affichage de l’arbre
Il y’a 3 façons générales d’affichage d’un arbre binaire à l’aide des parcours suivant :

Préfixé :
On affiche la racine, puis le sous arbre gauche, puis le sous arbre droit.

Affichage : 1 2 4 5 3 6 7.
Infixé :
On affiche le sous arbre gauche, puis la racine, puis le sous arbre droit.

Affichage : 4 2 5 1 6 3 7.
Postfixé :
On affiche le sous arbre gauche, puis le sous arbre droit, puis la racine.

Affichage : 4 5 2 6 7 3 1.

On a introduit aussi l’affichage des feuilles en écrivant une fonction qui n’affiche que
les nœuds qui n’ont pas des fils (fils_droit=fils_gauche=NULL). Ex : 4 5 6 7.

Affichage schématique horizontale : on utilise le parcours infixe pour réaliser ce type

d’affichage pour avoir le sous arbre droit en haut et affiche un nombre de tabulation
égale à la hauteur du nœud suivi par la valeur du nœud puis un retour chariot.

Note : malheureusement on n’a pas pu fait l’affichage vertical.

Page 5
 - Suppression d’un nœud
Pour les arbres binaires ordonnés horizontalement on a appliqué l’algorithme du cours
mais en ajoutant notre propre touche.

Pour les arbres binaires quelconques la suppression se fait toujours au niveau des feuilles
c.à.d. si le nœud à supprimer est une feuille un le supprime et on retourne la racine de
l’arbre sinon on le remplace par une feuille de ses fils puis on supprime la feuille.

- Chercher un nœud
La recherche se fait de la manière suivante :
Si le nœud est la racine on retourne 1 sinon on parcourt le sous arbre gauche puis droit
récursivement, si le nœud n’existe pas on retourne 0.

- Déterminer le nœud minimal

Initialiser une variable min par la racine puis parcourir le sous arbre gauche et comparer
les nœuds avec le min et remplacer au cas où on trouve une valeur inférieure, ensuite
refaire le même traitement dans le sous arbre droit d’une manière récursive dans les deux
cas, en fin retourner le min.

- Déterminer le nœud maximal

Initialiser une variable max par la racine puis parcourir le sous arbre gauche et comparer
les nœuds avec le max et remplacer au cas où on trouve une valeur supérieure, ensuite
refaire le même traitement dans le sous arbre droit d’une manière récursive dans les deux
cas, en fin retourner le max. même principe du min.

- Calcule de la hauteur d’un arbre

Pour calculer la hauteur d’un arbre, on commence par le calcul de la hauteur du sous arbre
gauche en incrémentant une variable récursivement ensuite on refait le traitement pour
le sous arbre droit puis on compare les deux hauteurs et à la fin on retourne la plus grande.

- Vider un arbre
Pour vider un arbre binaire, on parcourt l’arbre en supprimant la racine tant que la taille
de l’arbre est différente de 0, autrement dit tant que l’arbre est non vide.

Page 6
 III. Fonctions de manipulation :
1. Les fonctions communes des arbres binaires :
Voici quelques fonctions de manipulation des arbres binaires (Ordonnés/quelconques).
/* 1
Nom Fonction : creer_noeud
Entree : Un entier (val)
Sortie : Un nœud (Nd)
Description : la fonction crée un nouveau nœud
*/
Noeud*creer_noeud(int val)
{
Noeud *Nd;//declaration du nouveua noeud
Nd=(Noeud*)malloc(sizeof(Noeud));
if(!Nd)//echec d'allocation
{
printf("erreur d'allocation");
exit(-1);//sortir du programme
}//fin if
//initialisation du nœud crée
Nd->info=val;
Nd->left=Nd->right=NULL;
return ((Noeud*)Nd);
}//fin fonction
/* 3
Nom Fonction : Prefix_aff
Entree : racine d'un arbre (Arbre)
Sortie :
Description : la fonction permet l'affichage d'un arbre
a l'aide du parcours préfixe
*/
void Prefix_aff(Noeud *Arbre)
{
if(Arbre)
{
printf("%d\n",Arbre->info);
Prefix_aff(Arbre->left);
Prefix_aff(Arbre->right);
}
}//fin fonction
Page 7
 /* 4
Nom Fonction : infix_aff
Entrée : racine d'un arbre (Arbre)
Sortie :
Description : la fonction permet l'affichage d'un arbre
a l'aide du parcours infixe
*/
void infix_aff(Noeud *Arbre)
{
if(Arbre)
{
infix_aff(Arbre->left);
printf("%d\t",Arbre->info);
infix_aff(Arbre->right);
}
}//fin fonction
/* 5
Nom Fonction : Postfix_aff
Entrée : racine d'un arbre (Arbre)
Sortie :
Description : la fonction permet l'affichage d'un arbre
a l'aide du parcours Postfixe
*/
void postfix_aff(Noeud*Arbre )
{
if(Arbre)
{
postfix_aff(Arbre->left);
postfix_aff(Arbre->right);
printf("%d\t",Arbre->info);
}
}//fin fonction
/* 6
Nom Fonction : taille_Arbre
Entrée : racine d'un arbre (Arbre)
Sortie : nombre des nœuds de l'arbre
Description : la fonction retourne le nombre des nœuds
d'un arbre

Page 8
 */
int taille_Arbre(Noeud*Arbre)
{
if(!Arbre) return((int)0);//arbre vide
//retourner le nombre des fils gauche et droit et la racine
return ((int)(1+taille_Arbre(Arbre->left)+taille_Arbre(Arbre-
>right)));
}//fin fonction

/* 7
Nom Fonction : hauteur_Arbre
Entree : racine d'un arbre (Arbre)
Sortie : hauteur d'un arbre
Description : la fonction retourne la hauteur d'un arbre
en calculant la hauteur max gauche et max droit et
retourne la plus grande entre eux
*/
int hauteur_Arbre(Noeud*Arbre)
{
int hg,//pour stocker la hauteur max gauche
hd;//pour stocker la hauteur max droit
if(!Arbre) return((int)0);//arbre vide
//retourner le nombre des fils gauche et droit et la racine
else{
hg=hauteur_Arbre(Arbre->left);//hauteur gauche max
hd=hauteur_Arbre(Arbre->right);//hauteur droite max
//retourner la plus grande entre les deux
return((hd<hg)?((int)hg+1):((int)hd+1));
}
}//fin fonction

Page 9
 /* 8
Nom Fonction : max_arbre
Entree : racine d'un arbre (Arbre)
Sortie : noued le plus grand
Description : la fonction permet de retourner le
nœud le plus grand
*/
int max_arbre(Noeud* Arbre)
{
int max = Arbre->info;// max prend la valeur du racine
if (Arbre->left)
{ //determiner le max du sous arbre gauche
int gauche = max_arbre (Arbre->left);
//comparer et affecter le max avec le max gauche
max = (max > gauche ) ? max : gauche;
}
//refait la même procédure avec le sous arbre droit
if (Arbre->right)
{
int droit = max_arbre (Arbre->right);
max = (max > droit ) ? max : droit;
}
return max;
}
/* 9
Nom Fonction : min_arbre
Entree : racine d'un arbre (Arbre)
Sortie : noued le plus petit
Description : la fonction permet de retouner le
noued le plus petit
*/
int min_arbre(Noeud* Arbre)
{
int min = Arbre->info;// min prend la valeur du racine
if (Arbre->left)
{ //determiner le min du sous arbre gauche
int gauche = min_arbre (Arbre->left);
//comparer et affecter le min avec le min gauche

Page 10
 min = (min< gauche ) ? min : gauche;
}
//refait la meme procedure avec le sous arbre droit
if (Arbre->right)
{
int droit = min_arbre (Arbre->right);
min = (min < droit ) ? min : droit;
}
return min;
}
/* 12
Nom Fonction : aff_feuilles
Entrée : racine d'un arbre (Arbre)
Sortie :
Description : la fonction permet l'affichage de tous les
feuilles d'un arbre
*/
void aff_feuilles(Noeud*Arbre )
{
if(Arbre)
{
aff_feuilles(Arbre->left);
//si le noeud n'a pas des fils c'est une feuille
if((!Arbre->left)&&(!Arbre->right))
//afficher la feuille
printf(" \t\t\t%d\n",Arbre->info);
aff_feuilles(Arbre->right);

}
}//fin fonction
/* 13
Nom Fonction : Aff_Arbre_horiz
Entree : racine d'un arbre (Arbre)
Niveau de la racine (0)
Sortie :
Description : la fonction permet l'affichage de l'arbre
d'une manière horizontale
*/

Page 11
 void Aff_Arbre_horiz(Noeud *Arbre,int Niv)
{
int esp; //Pour l'affichage des espaces
if (Arbre) //Condition d'arret
{
//Affichage des fils droits
Aff_Arbre_horiz(Arbre->right,Niv+1);
printf("\n");
for (esp = 0; esp < Niv; esp++)
printf("\t");
printf("%d",Arbre->info);
//Affichage des fils gauches
Aff_Arbre_horiz(Arbre->left,Niv+1);
}
}//fin fonction
/* 14
Nom Fonction : rechercher
Entrée : racine d'un arbre (Arbre)
entier valeur cherche (val)
Sortie : un entier test=(0 ou 1)
Description : la fonction retourne 1 si une valeur passe
en argument existe dans l'arbre et 0 sinon
*/
int rechercher(Noeud*Arbre,int val)
{
int test=0;//test initialiser par 0
if(Arbre)
{ //si la valeur est trouve test=0+1 sinon reste égal 0
if(Arbre->info==val) return 1;
//chercher dans le sous arbre gauche
if (Arbre->left) test+= rechercher(Arbre->left,val);
// chercher dans le sous arbre droit
if(Arbre->right) test+= rechercher(Arbre->right,val);
}
//retourner test
return test;
}

Page 12
 /* 16
Nom Fonction : affichage
Entree : racine d'un arbre (Arbre)
Sortie :
Description : la fonction permet l'affichage de l'arbre
de plusieurs manières
*/
void affichage(Noeud*arbre)
{
int aff;
printf("\nQuelle type d'affichage voulez vous ?\n");
printf("\t\t1 affichage prefixe \n");
printf("\t\t2 affichage infixe \n");
printf("\t\t3 affichage postfixe \n");
printf("\t\t4 affichage schematise\n");
printf("\t\t5 affichage des feuilles de l'arbre\n");
scanf("%d",&aff);
if(!arbre) printf("l'arbre est vide\n");
else
{//cas où l’arbre est no vide
switch (aff)
{
case 1:
printf("-------\n");
Prefix_aff(arbre);
break;
case 2:
printf("-------\n");
infix_aff(arbre);
break;
case 3:
printf("-------\n");
postfix_aff(arbre);
break;
case 4: printf("-------\n");
Aff_Arbre_horiz(arbre,0);
break;
case 5:

Page 13
 printf("\t\tvoici tous les feuilles de l'arbre\n");
aff_feuilles(arbre);
break;
default:
printf("choix invalide\n");
break;
}
}//fin sinon
}

2. Les fonctions des arbres binaires ordonnés horizontalement :

/* 2 **
Nom Fonction : Inserer_Arbre_horiz
Entree : Un entier (val)
racine d'un arbre (Arbre)
Sortie : racine du nouveau arbre après l'insertion
Description : la fonction permet l'insertion d'un noeud dans
dans un arbre donne
*/
Noeud*Inserer_Arbre_horiz(Noeud*Arbre,int val)
{
Noeud*Nd;
if(!Arbre)//arbre vide ou (sous-arbre vide)
{
Nd=creer_noeud(val);
return((Noeud*)Nd);
}
if(Arbre->info>val)//val inferieur a l'étiquette du noeud
//insertion a gauche
Arbre->left=Inserer_Arbre_horiz(Arbre->left,val);
else// sinon
//insertion a droit
Arbre->right=Inserer_Arbre_horiz(Arbre->right,val);
return((Noeud*)Arbre);
}//fin fonction

Page 14
 /* 10 **
Nom Fonction : eliminer
Entree : Racine d'un arbre (ou sous arbre)(Arbre)
entier ver pour le fils que arbre doit
prendre
Sortie : racine de l'arbre (ou sous arbre) après le changement
Description : la fonction retourne le racine après le chainage et
l'élimination de du noeud d'un arbre (ou sous arbre)
*/
Noeud* eliminer(Noeud* Arbre,int ver)
{
Noeud* temp=Arbre;//pointeur de suppression
//ver=1 pas de fils droit, 0 pas de fils gauche
ver==1?(Arbre=Arbre->left):(Arbre=Arbre->right);
free(temp);//supprimer le nœud voulu
return ((Noeud*)Arbre);
}
/* 11 **
Nom Fonction : supp_Arbre
Entree : racine d'un arbre (Arbre)
valeur a supprimer (val)
Sortie : arbre après suppression
Description : la fonction reçoit un élément et le supprime
de l'arbre dont son racine est passe en argument
et retourne l'arbre après la suppression
*/
Noeud* supp_Arbre(Noeud*Arbre,int val)
{
if (!Arbre) return NULL;
//si l'element est dans l'arbre gauche
else if(val<(Arbre->info)) Arbre->left=supp_Arbre(Arbre->left,val);
//si l'element est dans l'arbre droit
else if(val>(Arbre->info))Arbre->right=supp_Arbre(Arbre->right,val);
else //val==Arbre->info
{
// s'il n y a pas de fils droit
if(!(Arbre->right)) Arbre=eliminer(Arbre,1);
// s'il n y a pas de fils gauche

Page 15
 else if(!(Arbre->left)) Arbre=eliminer(Arbre,0);
//si il y a les deux (droit et gauche)
else
Arbre->right=supp_Arbre(Arbre->right,((Arbre-
>info)=min_arbre(Arbre->right)));
}
return ((Noeud*)Arbre);
}//fin fonction

/* 15 **
Nom Fonction : vider_arbre_ordon
Entree : racine d'un arbre (Arbre)
Sortie : arbre vide
Description : la fonction supprime tous les noeuds
d'un arbre binaire ordonne horizontalement
*/
Noeud* vider_arbre_ordon(Noeud* Arbre)
{
//tanque la taille de l'arbre est diffèrent de 0
while(taille_Arbre(Arbre))
{ //supprimer la racine
Arbre=supp_Arbre(Arbre,Arbre->info);
}
//retourner l'arbre vide
return Arbre;
}

3. Les fonctions des arbres binaires quelconques :

/* 17
Nom Fonction : inserer_qlcq_2
Entrée : racine d'un arbre (Arbre)
entier à insérer
Sortie : arbre après l'insertion
Description : la fonction permet l'insertion dans un arbre
quelconque
*/
Noeud *inserer_qlcq_2(Noeud*arbre,int val )
{
Noeud*NE;
Page 16
 int ind;//indice du choix d’insertion
if(!arbre)//arbre vide
{ //créer le nouveau nœud
NE=creer_noeud(val);
return ((Noeud*)NE);
}
//inseret le choix d'insertion
printf("(1) pour gauche \n(2) pour droit \n");
scanf("%d",&ind);
//inseret a gauche
if(ind==1) arbre->left=inserer_qlcq_2(arbre->left,val);
//inseret a droite
else if(ind==2) arbre->right=inserer_qlcq_2(arbre->right,val);
//choix invalide
else printf("choix invalide, insertiion invalide\n "); return
((Noeud*)arbre);
return ((Noeud*)arbre);
}//fin fonction

/* 17 (deuxième version )
Nom Fonction : inserer_qlcq
Entrée : racine d'un arbre (Arbre)
entier à insérer
caractère indiquant l’insertion voulu
Sortie : arbre après l'insertion
Description : la fonction permet l'insertion dans un arbre
quelconque
*/

Noeud *inserer_qlcq(Noeud*arbre,int val ,char car)

{
Noeud*NE;
if(!arbre)//arbre vide
{
NE=creer_noeud(val);
return NE;
}
if(!arbre->left)//fils gauche vide
Page 17
 { //inserer dans le fils gauche
arbre->left=inserer_qlcq(arbre->left,val,car);
}
else if(!arbre->right)//fils droit vide
{ //inserer dans le fils droit
arbre->right=inserer_qlcq(arbre->right,val,car);
}
else //si les deux ne sont pas vide
{ if(car=='G')//inserer dans la sous arbre gauche
arbre->left=inserer_qlcq(arbre->left,val,car);
else if(car=='D')//inserer dans la sous arbre droit
arbre->right=inserer_qlcq(arbre->right,val,car);
//caractere incorrecte inseree
else{ printf("caractère invalide\n");return arbre;}
}//fin sinon
return ((Noeud*)arbre);
} //fin fonction

/* 18
Nom Fonction : chercher_feuille
Entree : racine d'un arbre (Arbre)
Sortie : pointeur de type Noued (feuille)
Description : la fonction permet de retourner une feuille
d'un arbre
*/
Noeud*chercher_feuille(Noeud*arbre)
{
if(!arbre) return arbre;
Noeud*q=arbre;
while ((q->right)||(q->left))
{ //si le fils gauche est n'existe pas
if(!(q->left)) q=q->right;
//si non passe vers le fils gauche
else q=q->left;
}
//retourner la feuille
return ((Noeud*)q);
}//fin fonction

Page 18
 /* 19
Nom Fonction : supprimer_qlcq
Entree : racine d'un arbre (Arbre)
valeur a supprimer (val)
Sortie : arbre après suppression
Description : la fonction reçoit un élément et le supprime
d'un arbre quelconque dont son racine est passe en
argument et retourne l'arbre après la suppression
*/
Noeud*supprimer_qlcq(Noeud*arbre,int val)
{
Noeud*tmp;
if(!arbre) return NULL;//arbre vide
else{
//si le noeud est diffèrent de val
if(arbre->info!=val)
{//faire la suppression a droit et à gauche
arbre->left=supprimer_qlcq(arbre->left,val);
arbre->right=supprimer_qlcq(arbre->right,val);
}
else//arbre->info=val
{ // s'il n y a pas de fils gauche
if(!(arbre->left)) arbre=eliminer(arbre,0);
// s'il n y a pas de fils droit
else if(!(arbre->right)) arbre=eliminer(arbre,1);
else//si il y a les deux (droit et gauche)
{// chercher une feuille à gauche
tmp=chercher_feuille(arbre->left);
//remplacer la valeur par la valeur de la feuille
arbre->info=tmp->info;
//supprimer la feuille
arbre->left=supprimer_qlcq(arbre->left,tmp->info);
}
}
}
return((Noeud*)arbre);

Page 19
 }//fin fonction

/* 20
Nom Fonction : vider_arbre_qlcq
Entrée : racine d'un arbre (Arbre)
Sortie : arbre vide
Description : la fonction supprime tous les nœuds
d'un arbre binaire quelconque
*/
Noeud* vider_arbre_qlcq(Noeud* Arbre)
{
//tanque la taille de l'arbre est différent de 0
while(taille_Arbre(Arbre))
{ //supprimer la racine
Arbre=supprimer_qlcq(Arbre,Arbre->info);
}
//retourner l'arbre vide
return Arbre;
}//fin fonction

IV. Programme principale main():

/* 21 **
Nom Fonction : gest_arbre_bin_horiz
Entree : racine d'un arbre (Arbre)
Sortie : racine arbre apres toute modification
Description : la fonction contient un menu de choix
contenant quelques fonction de gestion des arbres
binaires ordonnes horizontalements
*/
Noeud* gest_arbre_bin_horiz(Noeud*arbre)
{

int choix,val;
printf("\n--------ARBRE BINAIRE ORDONNE HORIZONTALEMENT--------\n");
do
{
Page 20
 printf("\n--------choisissez vous--------\n");
printf("1 inserer un noeud\n");
printf("2 supprimer un noeud\n");
printf("3 affichages \n");
printf("4 afficher le nombre des noeuds\n");
printf("5 afficher la hauteur de l'arbre\n");
printf("6 afficher le noeud min de l'arbre\n");
printf("7 afficher le noeud max de l'arbre\n");
printf("8 vider l'arbre\n");
printf("0 pour retourner au menu principale\n");
scanf("%d",&choix);
switch (choix)
{
case 1:
printf("entrer la valeur du noeud\n");scanf("%d",&val);
arbre=Inserer_Arbre_horiz(arbre,val);
if(!arbre)printf("erreur d'insertion\n");
else printf("insertion valide\n");
break;
case 2:
if(arbre)
{
printf("entrer la valeur a supprimer\n");scanf("%d",&val);
if(rechercher(arbre,val)==1)
{
arbre=supp_Arbre(arbre,val);
printf("suppression valide\n");
}
else printf("noeud n'existe pas\n");
}
else printf("arbre vide\n");
break;
case 3:
affichage(arbre);
break;
case 4:
if(arbre) printf("L'arbre contient %d
noeuds\n",taille_Arbre(arbre));

Page 21
 else printf("arbre vide\n");
break;
case 5:
if(arbre) printf("la hauteur de l'arbre est :
%d\n",hauteur_Arbre(arbre));
else printf("arbre vide\n");
break;
case 6:
if(arbre) printf("le noeud min est:%d\n",min_arbre(arbre));
else printf("arbre vide\n");

break;
case 7:
if(arbre) printf("le noeud max est:%d\n",max_arbre(arbre));
else printf("arbre vide\n");
break;
case 8:
if(arbre)
{
arbre=vider_arbre_ordon(arbre);
printf("l'arbre a ete vide\n");
}
else printf("L'arbre est deja vide\n");
break;
case 0:
printf("retour au menu\n");
break;

default:printf("choix invalide\n");
break;
}
} while (choix);
return((Noeud*)arbre);
}

Page 22
 /* 21 ***
Nom Fonction : gest_arbre_bin_horiz
Entree : racine d'un arbre (Arbre)
Sortie : racine arbre apres toute modification
Description : la fonction contient un menu de choix
contenant quelques fonction de gestion des arbres
binaires quelconques
*/

Noeud* gest_arbre_bin_qlcq(Noeud*arbre)
{
char car;
int choix,val;
printf("\n--------ARBRE BINAIRE QUELCONQUE--------\n");
do
{
printf("\n--------choisissez vous--------\n");
printf("1 inserer un noeud\n");
printf("2 supprimer un noeud\n");
printf("3 affichages \n");
printf("4 afficher le nombre des noeuds\n");
printf("5 afficher la hauteur de l'arbre\n");
printf("6 afficher le noeud min de l'arbre\n");
printf("7 afficher le noeud max de l'arbre\n");
printf("8 vider l'arbre\n");
printf("0 pour retourner au menu principale\n");
scanf("%d",&choix);

switch (choix)
{
case 1:
printf("entrer la valeur du noeud\n");scanf("%d",&val);
arbre=inserer_qlcq(arbre,val);
if(!arbre)printf("erreur d'insertion\n");
else printf("insertion valide\n");
break;

Page 23
 case 2:
if(arbre)
{
printf("entrer la valeur a supprimer\n");scanf("%d",&val);
if(rechercher(arbre,val)==1)
{
arbre=supprimer_qlcq(arbre,val);
printf("suppression valide\n");
}
else printf("noeud n'existe pas\n");
}
else printf("arbre vide\n");
break;
case 3:
affichage(arbre);
break;
case 4:
if(arbre) printf("L'arbre contient %d
noeuds\n",taille_Arbre(arbre));
else printf("arbre vide\n");
break;

case 5:
if(arbre) printf("la hauteur de l'arbre est :
%d\n",hauteur_Arbre(arbre));
else printf("arbre vide\n");
break;
case 6:
if(arbre) printf("le noeud min est:%d\n",min_arbre(arbre));
else printf("arbre vide\n");

break;
case 7:
if(arbre) printf("le noeud max est:%d\n",max_arbre(arbre));
else printf("arbre vide\n");
break;

Page 24
 case 8:
if(arbre)
{
arbre=vider_arbre_ordon(arbre);
printf("l'arbre a ete vide\n");
}
else printf("L'arbre est deja vide\n");
break;
case 0:
printf("retour au menu\n");
break;

default:printf("choix invalide\n");
break;
}
} while (choix);
return((Noeud*)arbre);
}

//FONCTION PRINCIPALE MAIN

int main()
{
Noeud*arbre1=NULL,*arbre2=NULL;
int choix,val;

do
{
printf("\n--------choisissez vous--------\n");
printf("1 Manipuler les arbre binaire ordonne horizontalement\n");
printf("2 Manipuler les arbre binaire quelconque\n");
printf("0 pour sortir du programme\n");
scanf("%d",&choix);
switch (choix)
{

Page 25
 case 1:
arbre1=gest_arbre_bin_horiz(arbre1);
break;
case 2:
arbre2=gest_arbre_bin_qlcq(arbre2);
break;
case 0:
printf("arret du programme\n");
break;

default:printf("choix invalide\n");
break;
}
} while (choix);

return ((int)0);

}//FIN PROGRAMME

V. Conclusion :
Ce TP nous a permis de savoir manipuler quelques fonctions de la gestion des arbres que ça soit
un arbre binaire ou un arbre quelconque. Malgré les difficultés qu’on a trouvé lors de la réflexion
à quelques problèmes dû à une mauvaise compréhension de la récursivité de quelques fonctions.

Page 26