From f5904379c91a724dcc5818fcb80e7b111dc6cf0d Mon Sep 17 00:00:00 2001 From: =?utf8?q?J=C3=A9r=C3=B4me=20Benoit?= Date: Fri, 10 Mar 2017 19:15:15 +0100 Subject: [PATCH] TP 5: Add corrections MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Signed-off-by: Jérôme Benoit --- TP5/exo4/liste_correction.c | 298 ++++++++++++++++++++++++++++++ TP5/exo5/pile_chaine_correction.c | 84 +++++++++ TP5/exo6/file_chaine_correction.c | 97 ++++++++++ 3 files changed, 479 insertions(+) create mode 100644 TP5/exo4/liste_correction.c create mode 100644 TP5/exo5/pile_chaine_correction.c create mode 100644 TP5/exo6/file_chaine_correction.c diff --git a/TP5/exo4/liste_correction.c b/TP5/exo4/liste_correction.c new file mode 100644 index 0000000..eff60c4 --- /dev/null +++ b/TP5/exo4/liste_correction.c @@ -0,0 +1,298 @@ +/********************************************************************/ +/* Implantation d'une liste triee d'entiers */ +/********************************************************************/ +#include +#include + +typedef int element; + +typedef struct cellule { + element valeur; + struct cellule *suivant; +} Cellule, *Liste; + + + +Liste ajouter_iter(element e, Liste L) +{ + Cellule *pc, *p1=L, *p2=NULL; + + pc = (Cellule *)malloc(sizeof(Cellule)); + pc->valeur=e;pc->suivant=NULL; + + if (!L) /* liste vide */ return pc; + while (p1 && (e >= p1->valeur)) + { + p2 = p1; + p1 = p1->suivant; + } + + if (!p2) /* insertion en tete */ {pc->suivant = L; L=pc; } + else {/* insertion entre p2 et p1 */ + p2->suivant = pc; + pc->suivant = p1; + } + + return L; +} + + +int longueur_iter(Liste L) +{ + int res = 0; + while(L) + { + res = res + 1; + L=L->suivant; + } + return res; +} + + +int longueur_rec(Liste L) +{ + if(!L) return 0; + return 1+longueur_rec(L->suivant); +} + + +void visualiser_iter(Liste L) +{ + while (L) + { + printf("%d ",L->valeur); + L = L->suivant; + } + printf("\n"); +} + + +void visualiser_aux(Liste L) +{ + if(L) + { + printf("%d ",L->valeur); + visualiser_aux(L->suivant); + } +} + + +void visualiser_rec(Liste L) +{ + visualiser_aux(L); + printf("\n"); +} + + +int rechercher_iter(element e, Liste L) +{ + while(L) + { + if(e == L->valeur) return 1; + L = L->suivant; + } + return 0; +} + + +int rechercher_rec(element e, Liste L) +{ + if(L == NULL) return 0; + if(e==L->valeur) return 1; + return rechercher_rec(e,L->suivant); +} + + +Liste rechercher_rec2(element e, Liste L) +{ + if(!L || e==L->valeur) return L; + else return rechercher_rec2(e,L->suivant); +} + + +Liste ajouter_rec(element e, Liste L) +{ + if(!L) + { + L=(Cellule *)malloc(sizeof(Cellule)); /* liste vide */ + L->valeur=e;L->suivant=NULL; + } + else if(e < L->valeur) /* ajouter DEVANT la tete */ + { + Cellule *p=(Cellule *)malloc(sizeof(Cellule)); + p->valeur=e; p->suivant=L; + L=p; /* nouvelle tete de liste */ + } + else L->suivant=ajouter_rec(e,L->suivant); /* ajouter DERRIERE la tete */ + return L; +} + + +Liste supprimer_iter(element e, Liste L) +{ + Liste prec = NULL; + while(L) + { + if(e == L->valeur) { + prec->suivant = L->suivant; /* le suivant de prec devient le suivant de L */ + free(L); /* liberation memoire pour L */ + return prec; + } + prec = L; + L = L->suivant; + } + return L; +} + + +Liste supprimer_rec(element e, Liste L) +{ + if(!L) ; /* element absent - on ne fait rien */ + else if(L->valeur==e) + { + Cellule *p=L; + L=L->suivant; + free(p); + } + else L->suivant=supprimer_rec(e,L->suivant); + return L; +} + + +Liste inverser_iter(Liste L) +{ + Liste cell=NULL; /* une cellule temporaire */ + Liste inv=NULL; /* la liste inversee */ + + while(L!=NULL) + { + cell=L; /* on prend la premiere cellule de la liste */ + L=L->suivant; /* le debut de la liste devient l'element suivant */ + cell->suivant=inv; /* on libere l'element de la liste et on le place en debut de la liste a renvoyer*/ + inv=cell; /* l'element qu'on vient de mettre en debut de liste devient le debut de la liste de a renvoyer */ + } + return inv; +} + + + +Liste inserer_fin(element e, Liste L) +{ + Cellule *pc, *p1=L, *p2=NULL; + pc = (Cellule *)malloc(sizeof(Cellule)); + pc->valeur=e;pc->suivant=NULL; + if (!L) return pc; + while (p1) + { + p2 = p1; + p1 = p1->suivant; + } + p2->suivant = pc; + pc->suivant = p1; + return L; +} + + +Liste inverser_rec(Liste L) +{ + if(L != NULL) { + return inserer_fin(L->valeur, inverser_rec(L->suivant)); + } + else return L; +} + + +/****************************************************************************/ + +int main() +{int x; + Liste L=NULL; + printf("liste vide\n"); + visualiser_iter(L); + visualiser_rec(L); + + printf("longueur=%d\n",longueur_iter(L)); + printf("longueur=%d\n",longueur_rec(L)); + + printf("ajout de 3\n"); + L=ajouter_iter(3,L); + printf("ajout de 6\n"); + L=ajouter_iter(6,L); + printf("ajout de 1\n"); + L=ajouter_iter(1,L); + printf("ajout de 10\n"); + L=ajouter_iter(10,L); + printf("ajout de 6\n"); + L=ajouter_iter(6,L); + visualiser_iter(L); + visualiser_rec(L); + + printf("longueur=%d\n",longueur_iter(L)); + printf("longueur=%d\n",longueur_rec(L)); + + printf("recherche de %d = %d\n",3,rechercher_iter(3,L)); + printf("recherche de %d = %d\n",3,rechercher_rec(3,L)); + printf("recherche de %d = %d\n",4,rechercher_iter(4,L)); + printf("recherche de %d = %d\n",4,rechercher_rec(4,L)); + + printf("ajout (rec) de 4\n"); + L=ajouter_rec(4,L); + visualiser_iter(L); + printf("ajout (rec) de 8\n"); + L=ajouter_rec(8,L); + visualiser_iter(L); + + printf("suppression (iter) de 4\n"); + supprimer_iter(4,L); + visualiser_iter(L); + printf("suppression (rec) de 6\n"); + supprimer_rec(6,L); + visualiser_iter(L); + + printf("liste inversee (iter)\n"); + Liste inv = inverser_iter(L); + visualiser_iter(inv); + + printf("Liste inversee (rec)\n"); + Liste inv2 = inverser_rec(inv); + visualiser_iter(inv2); + + /* il faut aussi tester chaque fonction (visualiser, supprimer, rechercher, inverser, ...) sur tous les cas : liste vide, liste avec un seul element, operation sur le premier element, operation sur le dernier element, ... */ +} + + +/****************************************************************************/ + +/* trace d'execution : +liste vide + + +longueur=0 +longueur=0 +ajout de 3 +ajout de 6 +ajout de 1 +ajout de 10 +ajout de 6 +1 3 6 6 10 +1 3 6 6 10 +longueur=5 +longueur=5 +recherche de 3 = 1 +recherche de 3 = 1 +recherche de 4 = 0 +recherche de 4 = 0 +ajout (rec) de 4 +1 3 4 6 6 10 +ajout (rec) de 8 +1 3 4 6 6 8 10 +suppression (iter) de 4 +1 3 6 6 8 10 +suppression (rec) de 6 +1 3 6 8 10 +liste inversee (iter) +10 8 6 3 1 +Liste inversee (rec) +1 3 6 8 10 +*/ + diff --git a/TP5/exo5/pile_chaine_correction.c b/TP5/exo5/pile_chaine_correction.c new file mode 100644 index 0000000..e4e562c --- /dev/null +++ b/TP5/exo5/pile_chaine_correction.c @@ -0,0 +1,84 @@ +/******************************************************************************* + Implantation d'un type Pile d'entiers sous forme chaînée + La pile est représentée par un pointeur. + La pile vide est représentée par NULL. +*******************************************************************************/ +#include +#include + +typedef int element; + +typedef struct cellule { + element valeur; + struct cellule *suivant; +} Cellule, *Pile; + +Pile pile_vide(void) +{ + return NULL; +} + +int est_vide(Pile p) +{ + return (p==NULL); /* ou return !p; */ +} + +element sommet(Pile p) +/* ATTENTION: consulter le sommet d'une pile vide n'a pas de sens */ +{ + if (est_vide(p)) + { + printf("Erreur - pile vide\n"); + exit(-1); + } + return p->valeur; /* la pile n'est pas modifiée */ +} + +Pile empiler(element e,Pile p) +{ + Cellule * pc=(Cellule *)malloc(sizeof(Cellule)); + pc->valeur=e;pc->suivant=p; + return pc; +} + +Pile depiler(Pile p) +/* ATTENTION: supprimer le sommet d'une pile vide n'a pas de sens */ +{ + Cellule * pc=p; + if (est_vide(p)) + { + printf("Erreur - pile vide\n"); + exit(-1); + } + p=p->suivant; + free(pc); + return p; +} + +element depiler2(Pile * p) /*ATTENTION: la pile est modifiée */ +/* ATTENTION: cette opération n'a pas de sens avec une pile vide */ +{ + Cellule *pc=*p; + element e; + if (est_vide(*p)) + { + printf("Erreur - pile vide\n"); + exit(-1); + } + e=(*p)->valeur; + *p=(*p)->suivant; + free(pc); + return e; +} + + +/******************************************************************************/ +int main() +{Pile p; + int i; + p=pile_vide(); + for (i=0; i<20; i++) p=empiler(i,p); + for (i=0; i<25; i++) printf("%d\n",depiler2(&p)); +} +/********************************************************************/ + diff --git a/TP5/exo6/file_chaine_correction.c b/TP5/exo6/file_chaine_correction.c new file mode 100644 index 0000000..f3c3369 --- /dev/null +++ b/TP5/exo6/file_chaine_correction.c @@ -0,0 +1,97 @@ +/************************************************************************** + Implantation d'un type File d'entiers sous forme chaînée + + La file est représentée par un doublet tête-queue de pointeurs + vers une cellule. + Le pointeur "tête" contient l'adresse de la tête de la file. + Le pointeur "queue" contient l'adresse de la queue de la file. + + La file vide est représentée par le doublet NULL-NULL + + Chaque cellule pointe vers la cellule suivante de la file +ou vers NULL si on est en queue de file. + +**************************************************************************/ +#include +#include + +typedef int element; +typedef struct cellule {element valeur; + struct cellule *suivant; } Cellule; + +typedef struct file { Cellule *t, *q; } File; /* tête queue */ + +File file_vide(void) +{ + File f={NULL,NULL}; + return f; +} + +int est_vide(File f) +{ + return !f.t; +} + +element tete(File f) +/* ATTENTION: consulter la tête d'une File vide n'a pas de sens */ +{ + if (est_vide(f)) {printf("Erreur - file vide\n"); exit(-1); } + return f.t->valeur; /* la File n'est pas modifiée */ +} + +File enfiler(element e,File f) +{ + Cellule *pc=(Cellule *)malloc(sizeof(Cellule)); + pc->valeur=e;pc->suivant=NULL; + + if (est_vide(f)) + f.t=f.q=pc; /* la cellule créée est à la fois tête et queue */ + else + f.q=f.q->suivant=pc; /* la cellule créée est la nouvelle queue */ + return f; +} + +File defiler(File f) +/* ATTENTION: supprimer la tête d'une File vide n'a pas de sens */ +{ + Cellule *pc=f.t; + if (est_vide(f)) + { + printf("Erreur - file vide\n"); + exit(-1); + } + if (f.t==f.q) f=file_vide(); /* la File n'avait plus qu'une seule cellule */ + else f.t=f.t->suivant; /* la queue ne change pas */ + free(pc); + return f; +} + +element defiler2(File *f) /* ATTENTION: la File est modifiée */ +/* ATTENTION: supprimer la tête d'une File vide n'a pas de sens */ +{ + Cellule *pc=f->t; + element e; + if (est_vide(*f)) + { + printf("Erreur - file vide\n"); + exit(-1); + } + e=f->t->valeur; + if (f->t==f->q) *f=file_vide(); /* la File n'avait plus qu'une seule cellule */ + else f->t=f->t->suivant; /* la queue ne change pas */ + free(pc); + return e; +} + + +/********************************************************************/ +int main() +{ + File p; + int i; + p=file_vide(); + for (i=0; i<20; i++) p=enfiler(i,p); + for (i=0; i<25; i++) printf("%d\n",defiler2(&p)); +} +/********************************************************************/ + -- 2.34.1