Faire un projet enc

Signaler
Messages postés
5
Date d'inscription
samedi 25 novembre 2006
Statut
Membre
Dernière intervention
10 mai 2008
-
Messages postés
5
Date d'inscription
samedi 25 novembre 2006
Statut
Membre
Dernière intervention
10 mai 2008
-
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;iinfo);


                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........

7 réponses

Messages postés
1243
Date d'inscription
jeudi 31 mars 2005
Statut
Membre
Dernière intervention
3 août 2016
2
Yop,

Fin du moi de février tu es sur ???? Sinon, soit plus précis dans ton problème, car cppfrance n'est pas là pour que l'on pose ces devoirs.

++
deck_bsd
___________________________________
[http://deck-bsd.eurower.net]
Messages postés
212
Date d'inscription
dimanche 3 avril 2005
Statut
Membre
Dernière intervention
28 mai 2011
2
ben jusqu'au fevrier prochain t'as encore plein de temps :p

<hr size="2" width="100%" />Trafic web gratuit!!!
Messages postés
5
Date d'inscription
samedi 25 novembre 2006
Statut
Membre
Dernière intervention
10 mai 2008

plutot le mois Avril,j'ai trompé..
tout le temps........
Messages postés
212
Date d'inscription
dimanche 3 avril 2005
Statut
Membre
Dernière intervention
28 mai 2011
2
bah de tt facon t'as tout ton temps :p

il n'y a qu'a selectionner les fonctions à groupper puis les mettre en fichiers à part et créer les fichiers d'entete .h

<hr size="2" width="100%" />Trafic web gratuit!!!
Messages postés
5
Date d'inscription
samedi 25 novembre 2006
Statut
Membre
Dernière intervention
10 mai 2008

mais comment faire ce regroupement ,svp je veux que vous m'aider un peut plus....

tout le temps........
Messages postés
1243
Date d'inscription
jeudi 31 mars 2005
Statut
Membre
Dernière intervention
3 août 2016
2
Et bien tu peut mettre tes fonction dans un fichier .h par exemple "fonctions.h" et dans ton projet après #include <malloc.h> mettre #include "fonctions.h".Attention ton fichier doit être dans le mm dossier ques les autres fichiers de ton projet.

++
deck_bsd
___________________________________
[http://deck-bsd.eurower.net]
Messages postés
5
Date d'inscription
samedi 25 novembre 2006
Statut
Membre
Dernière intervention
10 mai 2008

merci je vais l'éssayé

tout le temps........