Vous êtes sur la page 1sur 8

L->dernier = nouveau;

Correction TP 6 - Les listes chanes }

Exercice 1 void creeListeDecroissante(FListe L, int n){


printf("***** creeListeDecroissante() *****\n");
#include <stdio.h>
int i;
#include <stdlib.h>
Pelement Pel;
for(i=1; i<=n; i++){
typedef struct element * Pelement;
Pel = (Pelement)malloc( sizeof (Element));
typedef struct liste * FListe;
Pel->x = i;
typedef struct element{
insereUnElemt(L, Pel);
int x;
}
Pelement suivant;
}
}Element;

typedef struct liste{ void afficheListe(FListe L){


Pelement premier; L->courant = L->premier;
Pelement courant; while (L->courant != NULL){
Pelement dernier; printf("%d, ", L->courant->x);
}Liste; L->courant = L->courant->suivant;
}
void initListe(FListe L){ }
L = (FListe) malloc ( sizeof(Liste));
L->premier = (Pelement) malloc ( sizeof(Element)); Liste l;maListe = &l;
L->courant = (Pelement) malloc ( sizeof(Element));
L->dernier = (Pelement) malloc ( sizeof(Element)); int main(){
L->premier = NULL; initListe(maListe);
L->courant = NULL; creeListeDecroissante(maListe, 5);
L->dernier = NULL; printf("** afficheListe() ** \n[ ");
} afficheListe(maListe);

void insereUnElemt(FListe L, Pelement nouveau){ printf(" ]\n");


nouveau->suivant = L->premier; return 0;
L->premier = nouveau; }
if( L->dernier ==NULL )

1
Exercice 2 L->premier = nouveau;
if( L->dernier ==NULL )
#include <stdio.h> L->dernier = nouveau;
#include <stdlib.h> }

typedef struct element * Pelement; void creeListeDecroissante(FListe L, int n){


typedef struct liste * FListe; printf("***** creeListeDecroissante() *****\n");
int i;
typedef struct element{ Pelement Pel;
int x; for(i=1; i<=n; i++){
Pelement suivant; Pel = (Pelement)malloc( sizeof (Element));
}Element; Pel->x = i;
insereUnElemt(L, Pel);
typedef struct liste{ }
Pelement premier; }
Pelement courant;
Pelement dernier; void afficheListe(FListe L){
}Liste; L->courant = L->premier;
while (L->courant != NULL){
Liste l; printf("%d, ", L->courant->x);
FListe maListe = &l; L->courant = L->courant->suivant;
}
void initListe(FListe L){ }
L = (FListe) malloc ( sizeof(Liste));
L->premier = (Pelement) malloc ( sizeof(Element)); float moyenne(FListe L){
L->courant = (Pelement) malloc ( sizeof(Element)); int som = 0, cpt = 0;
L->dernier = (Pelement) malloc ( sizeof(Element)); L->courant = L->premier;
L->premier = NULL; while (L->courant != NULL){
L->courant = NULL; cpt++;
L->dernier = NULL; som += L->courant->x;
} L->courant = L->courant->suivant;
}
void insereUnElemt(FListe L, Pelement nouveau){
nouveau->suivant = L->premier; return (som/cpt);

2
} FListe maListe = &l;
FListe pl= &ll;
int main(){
initListe(maListe); void initListe(FListe L){
creeListeDecroissante(maListe, 5); L = (FListe) malloc ( sizeof(Liste));
printf("Liste = [ "); L->premier = (Pelement) malloc ( sizeof(Element));
afficheListe(maListe); L->courant = (Pelement) malloc ( sizeof(Element));
printf(" ]\n"); L->dernier = (Pelement) malloc ( sizeof(Element));
L->premier = NULL;
printf("Moyenne(Liste) = %.2f\n", moyenne(maListe)); L->courant = NULL;
return 0; L->dernier = NULL;
} }

void insereUnElemt(FListe L, Pelement nouveau){


Exercice 3 nouveau->suivant = L->premier;
L->premier = nouveau;
#include <stdio.h> if( L->dernier ==NULL )
#include <stdlib.h> L->dernier = nouveau;
#include <math.h> }

typedef struct element * Pelement; void creeListeDecroissante(FListe L, int n){


typedef struct liste * FListe; printf("***** creeListeDecroissante() *****\n");
int i;
typedef struct element{ Pelement Pel;
int x; for(i=1; i<=n; i++){
Pelement suivant; Pel = (Pelement)malloc( sizeof (Element));
}Element; Pel->x = i;
insereUnElemt(L, Pel);
typedef struct liste{ }
Pelement premier; }
Pelement courant;
Pelement dernier; void afficheListe(FListe L){
}Liste; printf("** afficheListe() **\n");
L->courant = L->premier;
Liste l, ll;

3
printf("Liste = [ ");
while (L->courant != NULL){ carres(maListe, pl);
printf("%d, ", L->courant->x); afficheListe(pl);
L->courant = L->courant->suivant; return 0;
} }
printf(" ]\n");
}
Exercice 5
void inserFinListe(FListe L, Pelement nouveau){
if (L->dernier ==NULL){ #include <stdio.h>
insereUnElemt(L, nouveau); #include <stdlib.h>
}else{
nouveau->suivant = L->dernier->suivant; typedef struct element * Pelement;
L->dernier->suivant = nouveau; typedef struct liste * FListe;
L->dernier = nouveau;
} typedef struct element{
} int x;
Pelement suivant;
void carres(FListe L, FListe Lc){ }Element;
Pelement el;
initListe(Lc); typedef struct liste{
L->courant = L->premier; Pelement premier;
while (L->courant != NULL){ Pelement courant;
el = (Pelement) malloc(sizeof(Element)); Pelement dernier;
el->x = pow(L->courant->x, 2); }Liste;
inserFinListe(Lc, el);
L->courant = L->courant->suivant; void initListe(FListe L){
} L = (FListe) malloc ( sizeof(Liste));
} L->premier = (Pelement) malloc ( sizeof(Element));
L->courant = (Pelement) malloc ( sizeof(Element));
int main(){ L->dernier = (Pelement) malloc ( sizeof(Element));
initListe(maListe); L->premier = NULL;
creeListeDecroissante(maListe, 5); L->courant = NULL;
afficheListe(maListe); L->dernier = NULL;
}

4
}
void insereUnElemt(FListe L, Pelement nouveau){
nouveau->suivant = L->premier; Liste l;
L->premier = nouveau; FListe maListe = &l;
if( L->dernier ==NULL )
L->dernier = nouveau; int main(){
} initListe(maListe);
creeListeDecroissante(maListe, 5);
void creeListeDecroissante(FListe L, int n){ afficheListe(maListe);
printf("***** creeListeDecroissante() *****\n"); supprimePremier(maListe);
int i; afficheListe(maListe);
Pelement Pel; return 0;
for(i=1; i<=n; i++){ }
Pel = (Pelement)malloc( sizeof (Element));
Pel->x = i;
insereUnElemt(L, Pel); Exercice 6
}
} #include <stdio.h>
#include <stdlib.h>
void afficheListe(FListe L){
L->courant = L->premier; typedef struct element * Pelement;
printf("Liste = [ "); typedef struct liste * FListe;
while (L->courant != NULL){
printf("%d, ", L->courant->x); typedef struct element{
L->courant = L->courant->suivant; int x;
} Pelement suivant;
printf(" ]\n"); }Element;
}
typedef struct liste{
void supprimePremier(FListe L){ Pelement premier;
Pelement el = L->premier; Pelement courant;
L->premier = L->premier->suivant; Pelement dernier;
free(el); }Liste;
el=NULL;
void initListe(FListe L){

5
L = (FListe) malloc ( sizeof(Liste)); printf(" ]\n");
L->premier = (Pelement) malloc ( sizeof(Element)); }
L->courant = (Pelement) malloc ( sizeof(Element));
L->dernier = (Pelement) malloc ( sizeof(Element)); void supprimeDernier(FListe L){
L->premier = NULL; Pelement el = L->dernier;
L->courant = NULL; Pelement avDernier;
L->dernier = NULL; L->courant = L->premier;
} while(L->courant->suivant->suivant !=NULL){
L->courant = L->courant->suivant;
void insereUnElemt(FListe L, Pelement nouveau){ }
nouveau->suivant = L->premier; avDernier = L->courant;
L->premier = nouveau; free(avDernier->suivant);
if( L->dernier ==NULL ) avDernier->suivant = NULL;
L->dernier = nouveau; L->dernier = avDernier;
} }

void creeListeDecroissante(FListe L, int n){ Liste l;


printf("***** creeListeDecroissante() *****\n"); FListe maListe = &l;
int i;
Pelement Pel; int main(){
for(i=1; i<=n; i++){ initListe(maListe);
Pel = (Pelement)malloc( sizeof (Element)); creeListeDecroissante(maListe, 5);
Pel->x = i; afficheListe(maListe);
insereUnElemt(L, Pel); supprimeDernier(maListe);
} afficheListe(maListe);
} return 0;
}
void afficheListe(FListe L){
L->courant = L->premier;
printf("Liste = [ "); Exercice 8
while (L->courant != NULL){
printf("%d, ", L->courant->x); #include <stdio.h>
L->courant = L->courant->suivant; #include <stdlib.h>
} /* Gestion d'une file FIFO */
#define MAX 5

6
nouveau=(Pelement)malloc(sizeof(Element));
typedef struct element * Pelement; nouveau->n = i;
typedef struct liste * Fliste; if ( fileVide(P) ){
struct element{ nouveau->suivant = NULL;
int n; P->premier = nouveau;
Pelement suivant; } else {
}Element; nouveau->suivant = P->premier;
P->premier = nouveau;
struct liste{ }
Pelement premier; P->taille++;
Pelement courant; }
int taille;
}Liste; void depiler(FListe P){
if ( !fileVide(P) ){
struct liste l; Pelement asupprimer;
FListe file = &l; asupprimer = P->premier;
P->premier = P->premier->suivant;
void initialiserFile(FListe P){ printf("Element retire de la file : %d\n",
P = (FListe)malloc(sizeof(Liste)); P->premier->n);
P->premier = free(asupprimer);
(Pelement)malloc(sizeof(Element)); asupprimer = NULL;
P->courant = }
(Pelement)malloc(sizeof(Element)); }
P->premier = NULL;
P->courant = NULL; void afficher(FListe P){
P->taille = 0; P->courant=P->premier;
} printf("File = ( ");
while (P->courant != NULL){
int fileVide(FListe P){ printf("%d, ",P->courant->n);
return (P->premier == NULL); P->courant = P->courant->suivant;
} }
printf(")\n");
void empiler(FListe P, int i){ }
Pelement

7
void creerFile(FListe P){ case 4:
int i, tab[MAX]= {3,4,5,6,7}; depiler(file);
for (i = 0; i<MAX; i++){ menu();
empiler(file, tab[i]); break;
} case 5:
} exit(0);
default:
int menu(){ printf("/!\\ Choix non valide /!\\ \n");
int choix, a; menu();
printf("*** Gestion d'une file ***\n"); }
printf(" 1 - Initialiser\n");
printf(" 2 - afficher\n"); }
printf(" 3 - Empiler \n");
printf(" 4 - Depiler\n"); int main(){
printf(" 5 - Quitter\n"); /* initialiserFile(file);
printf("Saisissez votre choix : "); creerFile(file);
scanf("%d",&choix); afficher(file);
switch (choix){ depiler(file);
case 1: afficher(file);
initialiserFile(file); */
printf("File initialisee\n"); menu();
menu(); return 0;
break; }
case 2:
afficher(file);
menu();
break;
case 3:
printf("Saisir entier a inserer dans la
file : ");
scanf("%d", &a);
empiler(file, a);
menu();
break;

Vous aimerez peut-être aussi