/**** partie interface ******/
/*****Liste unidirectionnelle*/
struct cellule
{
int cle ;
struct cellule *suivant ;
};
struct liste
{
struct cellule * premier ;
struct cellule * dernier ;
} ;
/******Fonction creer_liste*******/
void creer_liste(struct liste *);
/******Fonction liste_vide*******/
int liste_vide(struct liste );
/******Fonction inserer_avant_premier******/
void inserer_avant_premier(struct liste * , int );
/**Fonction Remplir 1 en utilisant inserer_avant_premier**/
void remplir1(struct liste * );
/******Fonction inserer_apres_dernier******/
void inserer_apres_dernier(struct liste * , int );
/**Fonction Remplir 1 en utilisant inserer_aprés_dernier**/
void remplir2(struct liste *);
/****Fonction TAILLE***/
int taille(struct liste );
/**** Fonction recherche_référence****/
struct cellule * recherche_reference(struct liste , int );
/***Fonction affiche***/
void affiche(struct liste );
/****Fonction insertion après élément référencée*****/
void inserer_apres_reference(struct cellule * , int );
/****Fonction insertion avant élément référencée*****/
void inserer_avant_reference(struct cellule * , int );
/*****Fonction suppression du premier élément****/
void supprimer_premier( struct liste * );
/*****Fonction suppression du dernier élément****/
void supprimer_dernier( struct liste * );
/*****Fonction suppression d’un élément référencée******/
void supprimer_element_reference( struct cellule *);
/*****Fonction supprimer_apres_reference******/
void supprimer_apres_reference(struct cellule *);
void supprimer_avant_reference(struct liste *, struct cellule *);
/* partie implementation */
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include "liste.h"
/******Fonction creer_liste*******/
void creer_liste(struct liste *L)
{
L->premier=NULL ;
L->dernier=NULL ;
}
/******Fonction liste_vide*******/
int liste_vide(struct liste L)
{
return [Link]==NULL;
}
/******Fonction inserer_avant_premier******/
void inserer_avant_premier(struct liste * L , int x)
{
struct cellule * p;
p = (struct cellule*)malloc(sizeof(struct cellule));
p->cle = x;
p->suivant = L->premier ;
if(L->premier==NULL)
L->dernier=p;
L->premier = p;
}
/**Fonction Remplir 1 en utilisant inserer_avant_premier**/
void remplir1(struct liste * L)
{
int x;
unsigned rep,i=1;
do
{
printf("Donner un entier %d de la liste: ",i);
scanf("%d",&x);
inserer_avant_premier(L , x);
do
{
printf("Voulez vous inserer un autre entier ds la liste(1:oui,0:non):
");
scanf("%u",&rep);
}while(!(rep==1 || rep==0));
i++;
}while(rep);
}
/******Fonction inserer_apres_dernier******/
void inserer_apres_dernier(struct liste * L , int x)
{
struct cellule *p;
p = (struct cellule*)malloc(sizeof(struct cellule));
p->cle = x;
p->suivant = NULL ;
if(L->dernier==NULL)
L->premier=p;
else
(L->dernier)->suivant=p;
L->dernier = p;
}
/**Fonction Remplir 1 en utilisant inserer_aprés_dernier**/
void remplir2(struct liste *L)
{
int x;
unsigned rep,i=1;
do
{
printf("Donner un entier %d de la liste: ",i);
scanf("%d",&x);
inserer_apres_dernier(L,x);
do
{
printf("Voulez vous inserer un autre entier ds la liste(1:oui,0:non):
");
scanf("%u",&rep);
}while(!(rep==1 || rep==0));
i++;
}while(rep);
}
/****Fonction TAILLE***/
int taille(struct liste L)
{
struct cellule * p;
unsigned t=0;
if(liste_vide(L))
return(0);
else
{
p=[Link];
while(p!=NULL)
{
p=p->suivant;
t++;
}
return(t);
}
}
/**** Fonction recherche_référence****/
struct cellule * recherche_reference(struct liste L , int x)
{
struct cellule * p=[Link];
while(p && p->cle!=x)
p= p->suivant;
return p;
}
/***Fonction affiche***/
void affiche(struct liste L)
{
struct cellule *q=[Link];
assert(!(liste_vide(L)));
while(q!=NULL)
{
printf("%d\t",q->cle);
q=q->suivant;
}
printf("\n");
}
/****Fonction insertion après élément référencée*****/
void inserer_apres_reference(struct cellule * p, int x)
{
struct cellule *q;
q = (struct cellule*)malloc(sizeof(struct cellule));
q->cle = x;
q->suivant = p->suivant ;
p->suivant=q;
}
/****Fonction insertion avant élément référencée*****/
void inserer_avant_reference(struct cellule * p, int x)
{
struct cellule *q;
q = (struct cellule*)malloc(sizeof(struct cellule));
*q = *p;
p->cle = x ;
p->suivant=q;
}
/*****Fonction suppression du premier élément****/
void supprimer_premier( struct liste * L)
{
struct cellule * p;
assert(!(liste_vide(*L)));
p= L->premier;
L->premier = p->suivant;
free(p);
/* exception une liste formée d’un seul élément */
if(L->premier ==NULL)
L->dernier=NULL;
}
/*****Fonction suppression du dernier élément****/
void supprimer_dernier( struct liste * L)
{
struct cellule * p; /*pour parcourir ll */
assert(!(liste_vide(*L)));
if(L->premier==L->dernier) /* liste formé d’un seul élément*/
supprimer_premier(L);
else
{
p=L->premier;
while(p->suivant!= L->dernier)
p=p->suivant;
p->suivant=NULL; /* mise à jour */
free(L->dernier); /* libérer le dernier */
L->dernier=p; /* mise à jour */
}
}
/*****Fonction suppression d’un élément référencée******/
void supprimer_element_reference( struct cellule *p)
{
struct cellule *q;
q=p->suivant;
*p=*q;
free(q);
}
/*****Fonction supprimer_apres_reference******/
void supprimer_apres_reference(struct cellule *p)
{
struct cellule * q;
q=p->suivant;
p->suivant=q->suivant;
free(q);
}
void supprimer_avant_reference(struct liste *, struct cellule *p)
{
struct cellule * q=l->premier;
while(q->suivant!=p)
q=q->suivant;
supprimer_element_reference(q);
if(q->suivant==NULL)
l->dernier=q;
}
/****************Partie Test****************/
#include <stdio.h>
#include "liste.h"
int main()
{
int x,y;
struct liste L1,L2;
struct cellule * p;
creer_liste(&L1) ;
creer_liste(&L2) ;
/*****Remplissage de la liste L1*****/
printf("***Remplissage de la liste L1***\n");
remplir2(&L1);
/*****Remplissage de la liste L2*****/
printf("***Remplissage de la liste L2***\n");
remplir2(&L2);
printf("***Contenu de la liste L1***\n");
affiche(L1);
printf("La taille de la liste L1 = %u\n",taille(L1));
printf("***Contenu de la liste L2***\n");
affiche(L2);
printf("La taille de la liste L2 = %u\n",taille(L2));
/*****inserer_avant_premier un élément donné dans L1*****/
printf("****Inserer un %cl%cment donn%c avant le premier dans L1****\
n",130,130,130);
printf("Donner l'entier d'insertion : ");
scanf("%d",&y);
inserer_avant_premier(&L1,y);
printf("***Contenu de la liste L1 apr%cs insertion (avant premier)***\n",130);
affiche(L1);
printf("La taille de la liste L1 = %u\n",taille(L1));
/*****inserer_aprés_dernier un élément donné dans L2*****/
printf("****Inserer un %cl%cment donn%c apr%cs le dernier ds L2****\
n",130,130,130,130);
printf("Donner l'entier d'insertion : ");
scanf("%d",&y);
inserer_apres_dernier(&L2,y);
printf("***Contenu de L2 apr%cs insertion (apr%cs dernier)***\n",130,130);
affiche(L2);
printf("La taille de la liste L2 = %u\n",taille(L2));
/*****inserer_apres_ref. un élément donné ds L1(la référence est différente du
premier et dernier)*****/
printf("*inserer un %clt. apr%cs r%cf. ds L1(la r%cf. est diff. du premier et
dernier)*\n",130,130,130,130);
printf("Donner un entier de recherche : ");
scanf("%d",&x);
p=recherche_reference(L1,x);
if(p)
{
printf("%d existe dans L1 et son r%cf%crence =%x\n",x,130,130,p);
printf("Donner l'entier d'insertion : ");
scanf("%d",&y);
inserer_apres_reference(p,y);
printf("***Contenu de la liste L1 apr%cs insertion***\n",130);
affiche(L1);
printf("La taille de la liste L1 = %u\n",taille(L1));
}
else
printf("La r%cf%crence de %d n'existe pas dans L1 \n",130,130,x);
/*****inserer_avant_ref. un élément donné ds L2(la ré[Link] différente du
premier et dernier)*****/
printf("*inserer un %clt. avant r%cf. ds L2(la r%cf. est diff. du premier et
dernier)*\n",130,130,130);
printf("Donner un entier : ");
scanf("%d",&x);
p=recherche_reference(L2,x);
if(p)
{
printf("%d existe dans L2 et son r%cf%crence =%x\n",x,130,130,p);
printf("Donner l'entier d'insertion : ");
scanf("%d",&y);
inserer_avant_reference(p,y);
printf("***Contenu de L2 apr%cs insertion***\n",130);
affiche(L2);
printf("La taille de la liste L2 = %u\n",taille(L2));
}
else
printf("La r%cf%crence de %d n'existe pas dans L2\n",130,130,x);
/*****Suppression du premier élément de la liste L1*****/
printf("****Suppression du premier %cl%cment de L1 ****\n",130,130);
supprimer_premier(&L1);
printf("***Contenu de L1 apr%cs suppression premier***\n",130);
affiche(L1);
printf("La taille de la liste L1 = %u\n",taille(L1));
/*****Suppression du dernier élément de la liste L2*****/
printf("****Suppression du dernier %cl%cment de la liste L2****\n",130,130);
supprimer_dernier(&L2);
printf("***Contenu de L2 apr%cs suppression dernier***\n",130);
affiche(L2);
printf("La taille de la liste L2 = %u\n",taille(L2));
/**suppression d’un élément référencé de L1(la réf. est différente du premier
et dernier)**/
printf("*supp. d'1 %clt. %c partir d'1e r%cf donn%ce de L1/r%cf. diff. du
premier et dernier",130,133,130,130,130);
printf("Donner un entier : ");
scanf("%d",&x);
p=recherche_reference(L1,x);
if(p)
{
printf("%d existe dans L1 et son r%cf%crence =%x\n",x,130,130,p);
supprimer_element_reference(p);
printf("***Contenu de la liste L1 apr%cs suppression***\n",130);
affiche(L1);
printf("La taille de la liste L1 = %u\n",taille(L1));
}
else
printf("La r%cf%crence de %d n'existe pas dans L1\n",130,130,x);
/*****suppression d’un élément apres une réf. de L2(la référence est différente
du premier et dernier)******/
printf("*supp. d'1 %clt. apr%cs une r%cf donn%c de L2/r%cf. est diff. du
premier et dernier\n",130,130,130,130);
printf("Donner un entier : ");
scanf("%d",&x);
p=recherche_reference(L2,x);
if(p)
{
printf("%d existe dans L2 et son r%cf%crence =%x\n",x,130,130,p);
supprimer_apres_reference(p);
printf("***Contenu de L2 apr%cs suppression***\n",130);
affiche(L2);
printf("La taille de la liste L2 = %u\n",taille(L2));
}
else
printf("La r%cf%crence de %d n'existe pas dans L2\n",130,130,x);
return 0;
}
