1

#include <stdio.h>
#include <stdlib.h>

typedef struct Noeud {

int val; // valeur(data)
struct Noeud* g; // gauche(left)
struct Noeud* d; // droit (right)
} * Arbre; // typedef pour un pointeur vers struct Noeud

// Fonction pour ceer un nouveau nœud

Arbre creerNoeud(int val) {
Arbre nouveauNoeud = (Arbre)malloc(sizeof(struct Noeud));
if (nouveauNoeud == NULL) {
fprintf(stderr, "Erreur lors de l'allocation\n");
exit(EXIT_FAILURE);
}
nouveauNoeud->val = val; Adresse
nouveauNoeud->g = NULL;

nouveauNoeud->d = NULL;
return nouveauNoeud;
}

// Fonction pour ins�rer un n�ud dans l'arbre binaire (recurisve)

void insererNoeud(Arbre* arbre, int ele) {
if (*arbre == NULL) {
*arbre = creerNoeud(ele);
} else {
if (ele <= (*arbre)->val) {
insererNoeud(&((*arbre)->g), ele);
} else {
insererNoeud(&((*arbre)->d), ele);
}
}
}
// ins�rer un n�ud dans l'arbre binaire (it�rative)
void insererNoeuditer(Arbre* arbre, int ele) {
Arbre nouv = creerNoeud(ele);
if (*arbre == NULL) {
*arbre = nouv;
La temp qui était égale racine va devient
return;
égale le droit de racine car 75 > 70 et come
}
75 < 77 et la gauche de 77 et pointer sur
Arbre temp = *arbre;
nulle donc doit devient pointer sur la nouveau
while (1) { nœud (75)
if (ele > temp->val) {
if (temp->d == NULL) {
temp->d = nouv;
break;
} else {
temp = temp->d;
}
} else {
if (temp->g == NULL) {
temp->g = nouv;
break;
} else {
temp = temp->g;
}
}
}
}
 2

// Fonction pour afficher l'arbre binaire de maniere plus structur�e

void afficherArbreStruct(Arbre, int niveau) {
if (arbre != NULL) {
int i;
afficherArbreStruct(arbre->d, niveau + 1);

for (i = 0; i < niveau; i++) {

printf(" ");
}
printf("|-- %d\n", arbre->val);
afficherArbreStruct(arbre->g, niveau + 1);
}
}

void prefixe(Arbre racine){

if (racine == NULL)
return;

printf("%d | ",racine->val);
prefixe(racine->g);
prefixe(racine->d);
return;
}
void infixe(Arbre racine){
if (racine == NULL)
return;
infixe(racine->g);
printf("%d | ",racine->val);
infixe(racine->d);
return;
}
void postfixe(Arbre racine){
if (racine == NULL)
return;
postfixe(racine->g);
postfixe(racine->d);
printf("%d | ",racine->val);
return;
}

// Affichage de l'arbre par Largeur

void afficherArbreNiveau(Arbre racine) {
if (racine == NULL) {
printf("L'arbre est vide.\n");
return;
}
File* file = creerFile();
enfiler(file, racine);
while (!estVide(file)) {
Arbre noeud;
noeud = defiler(file); // toPrint
printf("%d | ", noeud->val);
if (noeud->g != NULL) {
enfiler(file, noeud->g);//gauche
if (noeud->d != NULL) {
enfiler(file, noeud->d);//droit
}
}
}
 3

/* ************* | Min et Max |*************** */

int min(Arbre racine){

if(racine == NULL){
printf("L'arbre est vide.\n");
return;}
if(racine->g == NULL)
return racine->val;
return min(racine->g);
}
int max(Arbre racine){
if(racine == NULL){
printf("L'arbre est vide.\n");
return; }
if(racine->d == NULL)
return racine->val;
return max(racine->d);
}

/* ************* | Somme |*************** */

int somme(Arbre racine){

if(racine == NULL)return 0;

return racine->val + somme(racine->g) + somme(racine->d);

}

/* ************* | nmrbre impaire M |*************** */

void afficherImpaire(Arbre racine){
if(racine == NULL)
return;
if(racine->val %2 != 0 ){
printf("%d | ",racine->val);
}
afficherImpaire(racine->g);
afficherImpaire(racine->d);
}
/* ************* | Compter les nœuds |*************** */
int compterNoeuds(Arbre racine) {
if (racine == NULL) return 0;
return 1 + compterNoeuds(racine->g) + compterNoeuds(racine->d);
}
/* ************* | Calculer la hauteur |*************** */
int calculerHauteur(Arbre racine) {
if (racine == NULL) {
return 0;
} else {
// Calculer la hauteur des sous-arbres gauche et droit
int hauteurGauche = calculerHauteur(racine->g);
int hauteurDroit = calculerHauteur(racine->d);
// Retourner la hauteur maximale entre les sous-arbres gauche et droit plus 1
return 1 + (hauteurGauche > hauteurDroit ? hauteurGauche : hauteurDroit);
}
}
 4

// Vérifier si un arbre binaire est équilibré

int estEquilibre(Arbre racine) {
if (racine == NULL) {
return 1; // Un arbre vide est considéré comme équilibré
} else {
int hauteurGauche = calculerHauteur(racine->g);
int hauteurDroit = calculerHauteur(racine->d);
if (abs(hauteurGauche - hauteurDroit) <= 1 && estEquilibre(racine->g
&& estEquilibre(racine->d)) {
return 1; // L'arbre est équilibré si la différence de hauteur
est au plus 1 pour chaque nœud
} else {
return 0; // L'arbre n'est pas équilibré
}
}
}

// Vérifier si deux arbres binaires sont identiques

int sontIdentiques(Arbre arbre1, Arbre arbre2) {
// Si les deux arbres sont vides, ils sont identiques
if (arbre1 == NULL && arbre2 == NULL) {
return 1;
}
// Si l'un des arbres est vide et l'autre ne l'est pas, ils ne sont pas
identiques
if (arbre1 == NULL || arbre2 == NULL) {
return 0;
}
// Vérifier si les valeurs des nœuds sont identiques et si les sous-
arbres sont identiques
return (arbre1->val == arbre2->val &&
sontIdentiques(arbre1->g, arbre2->g) &&
sontIdentiques(arbre1->d, arbre2->d));
}
 5

int main() {
Arbre monArbre = NULL;

insererNoeud(&monArbre, 70);
insererNoeud(&monArbre, 60);
insererNoeud(&monArbre, 45);
insererNoeud(&monArbre, 64);
insererNoeud(&monArbre, 30);

insererNoeuditer(&monArbre, 52);
insererNoeuditer(&monArbre, 62);
insererNoeuditer(&monArbre, 77);
insererNoeuditer(&monArbre, 75);
insererNoeuditer(&monArbre, 81);

printf("Arbre binaire :\n\n");

afficherArbreStruct(monArbre, 0);
printf("\n");

printf("Arbre binaire prefixe :\n\n");

prefixe(monArbre);
printf("\n");
printf("\n");
printf("Arbre binaire infixe :\n\n");

infixe(monArbre);
printf("\n");
printf("\n");

printf("Arbre binaire postfixe :\n\n");

postfixe(monArbre);
printf("\n");

printf("Arbre binaire Largeur :\n\n");

afficherArbreNiveau(monArbre);
printf("\n");

printf("valeur minimum : %d ",min(monArbre));

printf("\n");
printf("valeur maximum : %d ",max(monArbre));
printf("\n");

printf("la some des element : %d ",somme(monArbre));

printf("\n");

printf("la nbr des element : %d ",compterNoeuds(monArbre));

printf("\n");
printf("la hauteur de cette arbre : %d ",calculerHauteur(monArbre));
printf("\n");

printf("Les nombres impaires : ");

afficherImpaire(monArbre);
printf("\n");

return 0;
}
 6

Pour suppression (vidéo) : click houn

// Fonction pour supprimer un nœud dans l'arbre binaire

Arbre supprimerNoeud(Arbre arbre, int val) {
if (arbre == NULL) {
return NULL;
}
// Si la valeur à supprimer est inférieure à la valeur du nœud courant,
// elle se trouve dans le sous-arbre gauche
if (val < arbre->val) {
arbre->g = supprimerNoeud(arbre->g, val);
}
// Si la valeur à supprimer est supérieure à la valeur du nœud courant,
// elle se trouve dans le sous-arbre droit
else if (val > arbre->val) {
arbre->d = supprimerNoeud(arbre->d, val);
}
// Si la valeur à supprimer est égale à la valeur du nœud courant
else {
// Cas 1: Le nœud à supprimer n'a pas d'enfant ou a un seul enfant
if (arbre->g == NULL) {
Arbre temp = arbre->d;
free(arbre);
return temp;
} else if (arbre->d == NULL) {
Arbre temp = arbre->g;
free(arbre);
return temp;
}
// Cas 2: Le nœud à supprimer a deux enfants
// Trouver le successeur (minimum) dans le sous-arbre droit
Arbre temp = trouverMinimum(arbre->d);
// Copier la valeur du successeur dans le nœud actuel
arbre->val = temp->val;
// Supprimer le successeur du sous-arbre droit
arbre->d = supprimerNoeud(arbre->d, temp->val);
}
return arbre;
}
int main() {
Arbre monArbre = NULL;
insererNoeud(&monArbre, 70);
insererNoeud(&monArbre, 60);
insererNoeud(&monArbre, 45);
insererNoeud(&monArbre, 64);
insererNoeud(&monArbre, 30);
insererNoeuditer(&monArbre, 52);
insererNoeuditer(&monArbre, 62);
insererNoeuditer(&monArbre, 77);
insererNoeuditer(&monArbre, 75);
insererNoeuditer(&monArbre, 81);

supprimerNoeud(monArbre,52);
printf("Arbre apres suppresstion :\n\n");
afficherArbreStruct(monArbre, 0);
printf("\n");
return 0;
}
 7

Arbre AVL
Facteur d'équilibre (FE) = hauteur(SousArbreGauche)−hauteur(SousArbreDroit)

1-3= -3
2-2 = 0 3-1=2

é=1 0 1-2= -1
0-2=2 0
1-0 = 1 1-0 = 1
0 0-1= -1
1-0=1

0 0 0
0

Un arbre est AVL si tous les nœuds ont un facteur de -1, 0 ou 1

Sinon on a les situations suivantes :

Cas 1
Initiale Ajout (10) Apres rotation
é=1
é=1
+1
é=1 é=1
+2
30 30
0
é 20
é
0 = é= +1 = é =
é
20 1
20
Rd(t) 0 =é = 0
é 1 é 11
10 1
1
30
=é = 0 é=1 é é
=é = é= é=
11 10 = =
é 11 1 1
1 1
Cas 2 =é =
Initiale Ajout (20) Apres rotation
1
é=1 +1
é =30
1 +2
é=1 é=1 0
30 30 20
é é
0 é
= é= -1 = é = Rgd(t) é=
10 1 20 =0é = 0
é 1 10 10 1 30
é 11 0 é=1
1
1
=é = é é
=é = 20 10 é = é= = é ==
11 11 é 1 1 1 1 1
=é = é=
1 1
 8

Cas 3

é=1 Initiale Ajout (30) Apres rotation

-1
é=1 é=1
-2é = 1
10 10 0
é 20
0 é é
= é= é=
= -1 20
1 1 20
é 1
Rg(t) 0 =é = 0
1 10 1 30
1
é= = é é=
0
é=1 é é
1 = é= é=
1 1 30 = =
Cas 4 1 é 1 1
1 1
é=
Initiale Ajout =(20) Apres rotation
é=1
1 1
-1 -2
é=1
é =101 é=1 0
10 10 20
é é
é
= é 0= = é+1= Rdg(t) é=
1 30 30 20 =0é = 0
1 11 1 10 1 30
é 0 é é=1 1é é
é= 20= é = é=
30 é= = é ==
= é 1
1 1
1 é 1
= 1 1 1 1
= é=
1
Situations du nœud a de 1sous arbres : 1

Ici, la rotation se fait par rapport à "a", donc le sous-arbre droit

de "a" devient le sous-arbre gauche de "b".
 9

Ici, la rotation se fait par rapport à "b", donc le sous-arbre

gauche de "b" devient le sous-arbre droit de "a".

"Ici, double rotation à gauche, c'est-à-dire que l'on effectue

d'abord une rotation à droite par rapport à "c" (donc le sous-arbre
droit de "c" devient le sous-arbre gauche de "b"), puis une rotation
à gauche se fait par rapport à "c". Ainsi, à la fin, le sous-arbre
gauche de "c" devient le sous-arbre droit de "a" et le sous-arbre
droit de "c" devient le sous-arbre gauche de "b"."

Faites-vous la double rotation à droite ?