slt, j'ai eu un programme en c mais je dois le réorganiser sous forme des fichier pour faire un projet ,il y a quelqu'un qui peut m'aider pour ce probléme? qui est:je n'ai aucune idée sur les fichier en c,et je dois rendre le projet à la fin du mois de février
/********************* Declaration des librairies *****************/
#include<stdio.h>
#include<malloc.h>
/******************************************************************/
/********************* Declaration des constantes *****************/
#define ECH_MACRO(x, y, t) ((t) = (x), (x) = (y), (y) = (t))
/******************************************************************/
/********************* Declaration des prototypes *****************/
typedef struct noeud
{
int info;
struct noeud *fg;
struct noeud *fd;
}NOEUD;
void affich_menu(void);
int* Saisie_tab(int *ptab, int nb_noeud);
void affich_infixe_croissant(NOEUD *a);
void affich_infixe_decroissant(NOEUD *a);
void affich_arbre(NOEUD *a, int profondeur);
int Somme(NOEUD *a);
int nbre_noeud(NOEUD *a);
NOEUD* creer_noeud(int nInfo);
NOEUD* inserer_tab(int *ptab, int taille);
void tri_tableau (int* ptab, int nombre);
void visite(NOEUD *a);
NOEUD* Recherche(NOEUD *a, int nInfo);
void Ajouter(NOEUD *a, int nInfo);
int supp_min(NOEUD *a, NOEUD *prec, int nRacine);
NOEUD* supprimer(NOEUD *a, NOEUD *prec, int nInfo);
void lib_mem(NOEUD *a);
/*****************************************************************/
/*********************** Programme principal *********************/
int main()
{
/* Declaration des variables et initialisation */
NOEUD *racine = NULL;
NOEUD *pRech = NULL;
/* initialisation a -1 permet de rentrer dans le switch au debut */
int choix = -1;
int* ptab;
int nb_noeud = 0;
int nInfo = 0;
int somme_info = 0;
/* Boucle du programme */
/* sort si choix = à 0 */
while(choix != 0)
{
/* affichage du menu */
affich_menu();
/* saisie du choix */
printf("\tVotre choix:\n");
scanf("%d",&choix);
/* acces au choix demandé */
switch(choix)
{
case 1: {
if(racine != NULL)
{
/* libération de la mémoire */
lib_mem(racine);
/* libération du tableau */
free(ptab);
}
/*Saisie du nombre de noeuds*/
printf("Combien de noeuds\n");
scanf("%d",&nb_noeud);
/*Creation du tableau*/
ptab = Saisie_tab(ptab, nb_noeud);
/*Insertion des noeuds jusqu'a la construction complete*/
racine = inserer_tab(ptab, nb_noeud);
break;
}
case 2: {
/*Recherche d'un element*/
printf("Info de l'element a rechercher:\n");
scanf("%d",&nInfo);
pRech = Recherche(racine, nInfo);
if(pRech == NULL)
printf("%d n'est pas dans l'arbre.\n", nInfo);
else printf("%d est dans l'arbre.\n", nInfo);
break;
}
case 3: {
/*Ajouter d'un element*/
printf("Info de l'element a ajouter:\n");
scanf("%d",&nInfo);
Ajouter(racine, nInfo);
break;
}
case 4: {
/*Saisie du noeud a modifier*/
printf("Noeud à modifier:\n");
scanf("%d",&nInfo);
/*recherche de l'existance du noeud*/
pRech = Recherche(racine, nInfo);
if(pRech != NULL)
{
/*Suppression du noeud*/
racine = supprimer(racine, NULL, nInfo);
/*Saisie de l'info du nouveau noeud*/
printf("Info du nouveau noeud:\n");
scanf("%d",&nInfo);
/*Ajout du nouveau noeud*/
Ajouter(racine, nInfo);
}
else printf("L'element n'est pas dans l'arbre.\n");
break;
}
case 5: {
/*Supprimer d'un element*/
printf("Info de l'element a supprimer:\n");
scanf("%d",&nInfo);
pRech = Recherche(racine, nInfo);
if(pRech != NULL)
racine = supprimer(racine, NULL, nInfo);
else printf("L'element n'est pas dans l'arbre.\n");
break;
}
case 6: {
/* Affichage de l'arbre en infixé croissant*/
printf("\nParcours infixe par ordre croissant:\n");
affich_infixe_croissant(racine);
printf("\n");
break;
}
case 7: {
/* Affichage de l'arbre en infixé decroissant*/
printf("\nParcours infixe par ordre decroissant:\n");
affich_infixe_decroissant(racine);
printf("\n");
break;
}
case 8: {
/* affichage de l'arbre graphiquement */
printf("Affichage de l'arbre graphiquement:\n");
affich_arbre(racine, 0);
printf("\n");
break;
}
case 9: {
somme_info = Somme(racine);
/* Affichage de la somme des infos */
printf("La somme des info est:%d",somme_info);
printf("\n");
break;
}
case 0:break;
default :{
printf("Choix impossible.\n");
break;
}
}
printf("\n\n");
}
if(racine != NULL)
{
/* lib,ration de la m,moire */
lib_mem(racine);
/* lib,ration du tableau */
free(ptab);
}
return 0;
}
/***************************************************************/
/************************ Definition des prototypes ************/
/***************************************************************/
/* Nom de la fonction:affich_menu */
/* But:affiche le menu */
/* Entrees: */
/* Sorties: */
/***************************************************************/
void affich_menu()
{
printf("\t\tManipulation d'arbre binaire:\n\n");
printf("\t1-> Creation d'un arbre ordonne.\n");
printf("\t2-> Recherche d'un element dans l'arbre.\n");
printf("\t3-> Ajout d'un element dans l'arbre.\n");
printf("\t4-> Modification d'un element dans l'arbre.\n");
printf("\t5-> Suppression d'un element dans l'arbre.\n");
printf("\t6-> Affichage de l'arbre par ordre croissant.\n");
printf("\t7-> Affichage de l'arbre par ordre decroissant.\n");
printf("\t8-> Affichage de l'arbre graphiquement.\n");
printf("\t9-> Calcul de la somme des infos des elements de l'arbre.\n");
printf("\t0-> Quitter\n\n");
}
/****************************************************************/
/* Nom de la fonction:Saisie du tableau */
/* But:saisir des info pour l'arbre */
/* Entrees:un pointeur sur un tableau , nombre */
/* de noeuds */
/* Sorties: un pointeur sur le tableau */
/****************************************************************/
int* Saisie_tab(int *ptab, int nb_noeud)
{
int loop;
/*Saisie du tableau*/
printf("Entrer les valeurs\n");
/* allocation dynamique du tableau */
ptab=(int*) malloc( sizeof(int) * nb_noeud );
for(loop=0 ; loop<nb_noeud ; loop++) scanf("%d",ptab+loop);
/*Tri du tableau*/
tri_tableau(ptab , nb_noeud);
return ptab;
}
/****************************************************************/
/* Nom de la fonction:affich_infixe_croissant */
/* But:affichage de l'arbre en infixe croissant */
/* Entrees:la racine de l'arbre */
/* Sorties: */
/****************************************************************/
void affich_infixe_croissant(NOEUD *a)
{
if(a!=NULL)
{
affich_infixe_croissant(a->fg);
/*operation sur le noeud*/
visite(a);
affich_infixe_croissant(a->fd);
}
}
/****************************************************************/
/* Nom de la fonction:affich_infixe_decroissant */
/* But:affichage de l'arbre en infixe decroissant */
/* Entrees:la racine de l'arbre */
/* Sorties: */
/****************************************************************/
void affich_infixe_decroissant(NOEUD *a)
{
if(a!=NULL)
{
affich_infixe_decroissant(a->fd);
/*operation sur le noeud*/
visite(a);
affich_infixe_decroissant(a->fg);
}
}
/****************************************************************/
/* Nom de la fonction:creer_noeud */
/* But:creer et initialise un noeud */
/* Entrees: */
/* Sorties:pointeur sur le noeud creé */
/****************************************************************/
NOEUD *creer_noeud(int nInfo)
{
/*declaration des variables*/
NOEUD *a;
/*allocation dynamique du noeud*/
a = (NOEUD*)malloc(sizeof(NOEUD));
a->info = nInfo;
a->fg = NULL;
a->fd = NULL;
return a;
}
/****************************************************************/
/* Nom de la fonction:inserer_tab */
/* But:creer un ABR à partir d'un tabmeau trié */
/* Entrees:la tableau et la taille du tableau */
/* Sorties:un pointeur sur la racine */
/****************************************************************/
NOEUD* inserer_tab(int *ptab, int taille)
{
/*Déclaration des variables*/
NOEUD *racine;
int new_taille;
/*Condition d'arret*/
if(taille==0) return NULL;
new_taille = (taille-1)/2 + (taille-1)%2;
/*creation du noeud*/
racine = (NOEUD*)malloc(sizeof(NOEUD));
racine->info = ptab[new_taille];
/*Recursion*/
racine->fg = inserer_tab(ptab,new_taille);
racine->fd = inserer_tab(&ptab[new_taille+1],(taille-1)/2);
return racine;
}
/****************************************************************/
/* Nom de la fonction:visite */
/* But:affiche le contenu d'un noeud */
/* Entrees:le pointeur sur le noeud */
/* Sorties: */
/****************************************************************/
void visite(NOEUD *a)
{
/* Affiche l'info du noeud visité ainsi que le nombre */
/* de noeuds sous lui en se comptant */
printf("%d(%d) ",a->info,nbre_noeud(a));
}
/****************************************************************/
/* Nom de la fonction:nbre_noeud */
/* But:compte le nombre de noeud dans les */
/* sous-arbres ainsi que le noeud lui-meme */
/* Entrees:un pointeur sur le noeud */
/* Sorties:le nombre de noeud */
/****************************************************************/
int nbre_noeud(NOEUD *a)
{
if(a == NULL) return 0;
return( 1+ nbre_noeud(a->fg) + nbre_noeud(a->fd));
}
/****************************************************************/
/* Nom de la fonction:tri_tableau */
/* But:tri un tableau par ordre croissant */
/* Entrees:un pointeur sur le tableau et sa taille */
/* Sorties: */
/****************************************************************/
void tri_tableau (int* ptab, int nombre)
{
/*declaration des variables*/
int temp, i, j, p_min;
/* on compare un element du tableau a tous les autres
et on inverse avec le plus petit */
for (i=0 ; i<nombre-1 ; i++)
{
p_min = i;
for (j = i + 1 ; j<nombre ; j++)
if (ptab[j] < ptab[p_min]) p_min = j;
if (p_min != i) ECH_MACRO (ptab[i], ptab[p_min], temp);
}
}
/****************************************************************/
/* Nom de la fonction:affich_arbre */
/* But:affichage de l'arbre */
/* Entrees:un pointeur sur un noeud , profondeur */
/* de la racine */
/* Sorties: */
/****************************************************************/
void affich_arbre(NOEUD *a, int profondeur)
{
int i;
if(a!=NULL)
{
affich_arbre(a->fd, profondeur+1);
/*operation sur le noeud*/
for(i=0;i<profondeur;i++)
printf("\t");
printf("%d\n",a->info);
affich_arbre(a->fg, profondeur+1);
}
}
/****************************************************************/
/* Nom de la fonction:Recherche */
/* But:recherche un element dans l'arbre */
/* Entrees:un pointeur sur un noeud et l'info */
/* Sorties:un pointeur sur le noeud recherché */
/****************************************************************/
NOEUD* Recherche(NOEUD *a, int nInfo)
{
/*Si arbre vide renvoie NULL*/
if(a == NULL) return NULL;
/*Sinon recherche iterative de l'info*/
while(a->info != nInfo)
{
if(a->info > nInfo)
a = a->fg;
else a = a->fd;
if(a == NULL) return NULL;
}
return a;
}
/****************************************************************/
/* Nom de la fonction:Ajouter */
/* But:Ajoute un element dans l'arbre */
/* Entrees:un pointeur sur un noeud et l'info du */
/* nouveau noeud */
/* Sorties: */
/****************************************************************/
void Ajouter(NOEUD *a, int nInfo)
{
NOEUD *pRech;
/*Recherche de l'element nInfo*/
pRech = Recherche(a, nInfo);
/*S'il n'existe pas on l'ajoute*/
if(pRech == NULL)
{
pRech = a;
/*Tant que l'on a pas atteint la feuille*/
/*voulue , on parcoure l'arbre*/
while(a != NULL)
{
/*Permet de mémoriser le pere*/
pRech = a;
/*Parcour de l'arbre*/
if(a->info > nInfo)
a = a->fg;
else a = a->fd;
}
/*Creation du noeud*/
a = creer_noeud(nInfo);
/*Insertion dans l'arbre*/
if(pRech->info > nInfo)
pRech->fg = a;
else pRech->fd = a;
}
else printf("Il existe deja.\n");
}
/****************************************************************/
/* Nom de la fonction:supp_min */
/* But:supprimer l'element minimum du sous _arbre droit */
/* Entrees:un pointeur sur un noeud, son pere et */
/* nRacine permet de savoir si c'est la premiere fois */
/* que l'on rentre dans la fonction */
/* Sorties: retourne l'info de l'element mini */
/****************************************************************/
int supp_min(NOEUD *a, NOEUD *prec, int nRacine)
{
int resultat = 0;
if(a->fg == NULL)
{
resultat = a->info;
/*si a=racine alors prec->fd = NULL*/
if(nRacine == 1) prec->fd = NULL;
/*sinon*/
else prec->fg=NULL;
free(a);
return resultat;
}
else return supp_min(a->fg, a, 0);
}
/****************************************************************/
/* Nom de la fonction:supprimer */
/* But:supprimer un element de l'arbre */
/* Entrees:un pointeur sur un noeud, son pere et l'info */
/* Sorties: retourne le noeud */
/****************************************************************/
NOEUD* supprimer(NOEUD *a, NOEUD *prec, int nInfo)
{
NOEUD *p;
if(a != NULL)
{
/*Recherche du noeud*/
if(nInfo < a->info)
p = supprimer(a->fg,a, nInfo);
else if(nInfo > a->info)
p = supprimer(a->fd, a, nInfo);
/*Si le noeud à effacer est une feuille...*/
else if((a->fg == NULL)&&(a->fd == NULL))
{
/*Si le noeud a supprimer est la racine*/
if(prec == NULL) return NULL;
/*Sinon*/
if(prec->fd==a) prec->fd=NULL;
else prec->fg=NULL;
free(a);
return a;
}
/*Si le noeud à effacer n'a pas de fils gauche*/
else if(a->fg == NULL)
{
if(prec->fd==a) prec->fd=a->fd;
else prec->fg=a->fd;
free(a);
return a;
}
/*Si le noeud à effacer n'a pas de fils droit*/
else if(a->fd == NULL)
{
if(prec->fd==a) prec->fd=a->fg;
else prec->fg=a->fg;
free(a);
return a;
}
/*Si le noeud à un fils gauche et un fils droit*/
else
{
a->info = supp_min(a->fd, a, 1);
return a;
}
}
/*Test si l'arbre est vide*/
if(p!=NULL)
return a;
else return NULL;
}
/****************************************************************/
/* Nom de la fonction:Somme */
/* But:fait la somme des infos dans l'arbre */
/* Entrees:un pointeur sur un noeud */
/* Sorties: retourne la somme des infos */
/****************************************************************/
int Somme(NOEUD *a)
{
int somme = 0;
if(a == NULL) return 0;
somme = Somme(a->fg);
somme += a->info;
somme += Somme(a->fd);
return somme;
}
/****************************************************************/
/* Nom de la fonction:lib_mem */
/* But:detruit l'arbre s'il existe */
/* Entrees:un pointeur sur un noeud */
/* Sorties: */
/****************************************************************/
void lib_mem(NOEUD *a)
{
if(a==NULL) return;
lib_mem(a->fg);
lib_mem(a->fd);
free(a);
}
/* Date de modification: */
merci
tout le temps........