Sujet Précédent Sujet Suivant

Faire un projet enc

cs_nana87 Messages postés 5 Date d'inscription samedi 25 novembre 2006 Statut Membre Dernière intervention 10 mai 2008 - 14 avril 2007 à 19:57
cs_nana87 Messages postés 5 Date d'inscription samedi 25 novembre 2006 Statut Membre Dernière intervention 10 mai 2008 - 16 avril 2007 à 20:58
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........
A voir également:

7 réponses

Réponse 1 / 7
deck_bsd Messages postés 1243 Date d'inscription jeudi 31 mars 2005 Statut Membre Dernière intervention 3 août 2016 2
14 avril 2007 à 23:08
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]
0
Réponse 2 / 7
goast_tu Messages postés 212 Date d'inscription dimanche 3 avril 2005 Statut Membre Dernière intervention 28 mai 2011 2
15 avril 2007 à 18:26
ben jusqu'au fevrier prochain t'as encore plein de temps :p

<hr size="2" width="100%" />Trafic web gratuit!!!
0
Réponse 3 / 7
cs_nana87 Messages postés 5 Date d'inscription samedi 25 novembre 2006 Statut Membre Dernière intervention 10 mai 2008
15 avril 2007 à 19:28
plutot le mois Avril,j'ai trompé..
tout le temps........
0
Réponse 4 / 7
goast_tu Messages postés 212 Date d'inscription dimanche 3 avril 2005 Statut Membre Dernière intervention 28 mai 2011 2
16 avril 2007 à 19:30
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!!!
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 7
cs_nana87 Messages postés 5 Date d'inscription samedi 25 novembre 2006 Statut Membre Dernière intervention 10 mai 2008
16 avril 2007 à 19:51
mais comment faire ce regroupement ,svp je veux que vous m'aider un peut plus....

tout le temps........
0
Réponse 6 / 7
deck_bsd Messages postés 1243 Date d'inscription jeudi 31 mars 2005 Statut Membre Dernière intervention 3 août 2016 2
16 avril 2007 à 20:43
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]
0
Réponse 7 / 7
cs_nana87 Messages postés 5 Date d'inscription samedi 25 novembre 2006 Statut Membre Dernière intervention 10 mai 2008
16 avril 2007 à 20:58
merci je vais l'éssayé

tout le temps........
0

Discussions similaires

projet gestion d'un cabinet médical
cs_omartn -
Exploreur -

3 réponses
Exemple des projets ou des minis projets en php/POO
abdeslam2009 -
abdeslam2009 -

2 réponses
mini projet C++
cs_debuteur -
chtitfred -

3 réponses
Idée de projet utilisant une BDD
cypress78 -
jhon512 -

4 réponses
Rapport de projet BTS IRIS
chooloveloo -
assala -

4 réponses
Debutant: Comment creer un projet
dbzonline -
dbzonline -

7 réponses
Rejoignez-nous