Salut.....
Alors merci infiniment pour ta reponse et pour le code de mon programme le voilà complet:
// essai.cpp : fichier projet principal.
#include
<stdafx.h>#include
<stdio.h>#include
<malloc.h>/*DECLARATION DES TYPES*/
typedef
struct noeud{
int cle;struct noeud *fg;struct noeud *fd;}NOEUD,Arber;
/* Declaration de Type NOEUD et Arber*/typedef
enum BOOLEEN { FAUX=0, VRAI=1 };/*Declaration du type BOOLEEN*//*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entrées: une arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
Inisialisation(Arber *a){
a=NULL;
}
/*****************************************************************************************/
/*Principe de la Fonction: preparer un noeud et retourn l'adresse de ce noeud */
/*les entres: une cle */
/*la sortie: type NOEUD */
/*****************************************************************************************/
NOEUD* PreparerNoeud(
int CLE){
NOEUD *a;
a = (NOEUD*)malloc(
sizeof(NOEUD));if (a!= NULL){
a->cle=CLE;
a->fd=NULL;
a->fg=NULL;
}
return a;}
/*****************************************************************************************/
/*Principe de la Fonction: Ajouter un noeud retourn booleen si la cle du noeud existe */
/*déjà il retourne FAUX sinon il retourn VRAI */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
BOOLEEN AjouterNoeud(Arber *a,NOEUD *n)
{
if (a==NULL){
a=n;
return VRAI;}
else{
if(n->cle == a->cle)return FAUX;if (n->cle < a->cle )return AjouterNoeud( a->fg,n);elsereturn AjouterNoeud( a->fg,n);}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'un element (une clé) retourn FAUX */
/*si la clé existe déjà ou ya pas d'espace memoire */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
BOOLEEN AjouterElement(Arber *a,
int CLE){
NOEUD *n;
n=PreparerNoeud( CLE);
if
(n ==NULL)return FAUX;else
{
if (AjouterNoeud(a,n)==VRAI)return VRAI;else{
return FAUX;delete n;}
}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
BOOLEEN ExisteCle(Arber *a,
int CLE){
if (a==NULL) return FAUX;else{
if (a->cle== CLE) return VRAI;if (CLE< a->cle) return ExisteCle(a->fg, CLE);if (CLE> a->cle) return ExisteCle(a->fd, CLE);}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
NOEUD* ExtraireMax(Arber *a)
{
NOEUD *n;
if (a==NULL) return NULL;else{
if (a->fd==NULL){
n=a;
a=a->fg;
return n;delete n;}
}
ExtraireMax( a->fd);
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
BOOLEEN SupprimmerRacine(Arber *a)
{
NOEUD *n;
if (a==NULL){
return FAUX;}
n=a;
if (n->fg==NULL) {
a=n->fd;
}
else{
if (n->fd==NULL) {
a=n->fg;
}
else{
a=ExtraireMax(n->fg);
a->fd=n->fd;
a->fg=n->fg;
}
}
delete n;return VRAI;}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
BOOLEEN ExtraireElement(Arber *a,
int CLE){
char e;if (a==NULL) return FAUX;if (CLE< a->cle) return ExtraireElement(a->fg, CLE);if (CLE> a->cle) return ExtraireElement(a->fd, CLE);e=a->cle;
return SupprimmerRacine(a);}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
InsererNoeud(Arber *a,NOEUD *n){
if
(n->cle<a->cle){
if (a->fg!=NULL) return InsererNoeud( a->fg,n);elsea->fg=n;
}
else
{
if (n->cle>a->cle){
if (a->fd!=NULL) return InsererNoeud( a->fd,n);else a->fd=n;}
else printf ("\ncette cle existe déjà");}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
affich_infixe_croissant(Arber *a){
if(a!=NULL){
affich_infixe_croissant(a->fg);
printf(
"%d\n",a->cle);affich_infixe_croissant(a->fd);
}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
affich_pre(Arber *racine){
if (racine==NULL)return;printf(
"\n%d ",racine->cle);affich_pre(racine->fg);
affich_pre(racine->fd);
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
affich_pos(Arber *racine){
if (racine==NULL)return;affich_pos(racine->fg);
affich_pos(racine->fd);
printf(
"\n%d ",racine->cle);}
Arber* ExtraireSousAD(Arber *a)
{
if
(a==NULL) return NULL;else
{
return
a->fd;a->fd=NULL;
}
}
//****************************************/
Arber* ExtraireSousAG(Arber *a)
{
if
(a==NULL) return NULL;else
{
return
a->fg;a->fg=NULL;
}
}
/*****************************************************************************************/
/*Principe de la Fonction: initialisation d'une arbre */
/*les entres: un arbre, */
/*la sortie: VOID */
/*****************************************************************************************/
void
affich_menu(){
printf(
"\t\tManipulation d'arbre binaire:\n\n");printf(
"\t1-> Creation d'un arbre ordonne(OBLIGATOIR).\n");printf(
"\t2-> affichage infixe.\n");printf(
"\t3-> affichage prefixe.\n");printf(
"\t4-> affichage postfixe.\n");printf(
"\t5->Inistialisation.\n");printf(
"\t6-> preparation d un noeud.\n");printf(
"\t7-> Ajout d un noeud.\n");printf(
"\t8-> Ajout d'un element.\n");printf(
"\t9-> existance d une cle.\n");printf(
"\t10-> Extraire un element.\n");printf(
"\t11-> Etraire l adresse du noeud contenant la cle maximal.\n");printf(
"\t12-> Iserstion d un noeud .\n");printf(
"\t13-> supprission de la racine.\n");printf(
"\t0-> Quitter\n\n");}
int
main (){
/* Declaration des variables et initialisation */
Arber *A,*Fg,*Fd;
char reponse;NOEUD *racine ,*Nracine;
NOEUD *n ;
/* initialisation a -1 permet de rentrer dans le switch au debut */int choix = -1;int nb_noeud = 0;char information ,R_info;int R_cle,i;int cle;BOOLEEN Bool;
printf(
"vouler vous tester les manipulations sur les arbres? o/n? ");scanf (
"\n%s",& reponse);if (reponse=='o') {
while
(choix != 0){
/* affichage du menu */affich_menu();
/* saisie du choix */printf(
"\tVotre choix:\n");scanf(
"\n%d",&choix);/* acces au choix demandé */switch(choix){
case 1: {printf(
"donner le nmbr des noeuds\n");scanf(
"\n%d",&nb_noeud);printf(
"donner la cle de la racine\n");scanf(
"\n%d",&R_cle);racine=PreparerNoeud(R_cle);
printf(
"donner les cles des noeuds\n");i=2;
while (i<=nb_noeud){
scanf(
"\n%d",&cle);n=PreparerNoeud(cle);
InsererNoeud(racine,n);
i=i+1;
}
break;}
case 2: {printf(
"********************************************\n");printf(
"L affichage est comme suite....\n");affich_infixe_croissant(racine);
printf(
"********************************************\n");
break;}
case 3: {printf(
"********************************************\n");printf(
"L affichage est comme suite....\n");affich_pre(racine);
printf(
"\n********************************************\n");break;}
case 4:{ printf(
"\n********************************************\n");printf(
"L affichage est comme suite....\n");affich_pos(racine);
printf(
"\n********************************************\n");break;}
case 5:printf(
"\n********************************************\n");{
Inisialisation(racine);
printf(
"l arbre est intialiser\n");printf(
"\n********************************************\n");
break;}
case 6:printf(
"\n********************************************\n");{
printf(
"donner la cle a inserer\n");scanf(
"\n%d",&cle);A=PreparerNoeud(cle);
printf(
"L adress du noeud preparer est =%d",&A);printf(
"\n********************************************\n");break;}
case 7:printf(
"\n********************************************\n");{
printf(
"Preparation d un noeud..\n");printf(
"donner la cle a inserer\n");scanf(
"\n%d",&cle);n=PreparerNoeud(cle);
Bool=AjouterNoeud( racine,n);
if (Bool==VRAI){
printf (
"Vous pouvez l'inserer\n");}
if (Bool==FAUX) printf("Desole, impossible de l'inserer car sa cle existe deja\n");break;printf(
"\n********************************************\n");}
case 8:{
printf(
"\n********************************************\n");printf(
"Donner l element a ajouter.\n");scanf(
"\n%d",&cle);Bool=AjouterElement(racine, cle);
if (Bool==VRAI) printf ("Vous pouvez inserer cette element.\ ");if (Bool==FAUX) printf("Desole, impossible de l'inserer peu etre que elle existe deja! ou bien ya pas d'espace memoire!\n");break;printf(
"\n********************************************\n");}
case 9:printf(
"\n********************************************\n");{
printf(
"Donner la cle.\n");scanf(
"\n%d",&cle);Bool=ExisteCle(racine,cle);
if (Bool==VRAI){
printf (
" la cle existe ");}
if (Bool==FAUX){
printf(
"la cle n'existe pas");}
break;printf(
"\n********************************************\n"); }
case 10:{
printf(
"\n********************************************\n");printf(
"Donner la cle.\n");scanf(
"\n%d",&cle);Bool=ExtraireElement(racine,cle);
if (Bool==VRAI) printf ("la cle exsite et le noeud corespondant est supprimme");if (Bool==FAUX)("Desole, la cle n'existe pas!");break; printf(
"\n********************************************\n");}
case 11:{
printf(
"\n********************************************\n");A=ExtraireMax(racine);
printf (
"la'dresse du maximum =%d",&A);break;printf(
"\n********************************************\n");}
case 12:{
printf(
"\n********************************************\n");printf(
"Dabord la preparation du noeud\n"); printf(
"Donner la cle.\n");scanf(
"\n%d",&cle);n=PreparerNoeud(cle);
InsererNoeud(racine,n);
printf(
"le noeud est insere");
break;printf(
"\n********************************************\n");}
case 13:{
printf(
"\n********************************************\n");SupprimmerRacine(racine);
printf(
"la racine est supprimme.");printf(
"\n********************************************\n");break;}
case 0:break;default :{printf(
"Choix impossible.\n");break;}
}
printf(
"\n\n");}
}
else{
if (reponse=='n')printf("Merci pour votre de votre attantion tout de meme");else printf("Entrer la bonne reponse SVP...");}
return (0);}