Comment faire un projet en c???????

/********************* 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: */