#include <stdio.

h>
#include <stdlib.h>
#include <string.h>

typedef void Object;

//Structure d'une Liste doublement chainée

typedef struct CelluleDbl* PCelluleDbl;

typedef struct CelluleDbl
{
Object* valeur;
PCelluleDbl suivant;
PCelluleDbl precedent;
int donnee;
}Liste;

//Creation Liste

void CreerListeDbl(PCelluleDbl l, int taille)

{
PCelluleDbl tete;
PCelluleDbl p;
int i;
int donnee;
printf("\nEntrez le premier element de la liste : ");
scanf("%d",&donnee); fflush(stdin);
tete=l;
tete->valeur= donnee;
tete->suivant= NULL;
tete->precedent= NULL;

//Ajouter les autres elements à la liste

for (i=2;i<=taille;i++)
{
p=malloc(sizeof(PCelluleDbl));
printf("\nEntrez l'element suinant :");
scanf("%d",&donnee);
p->valeur= donnee;
p->suivant= NULL;
p->precedent= NULL;
tete->suivant= p;
tete= p;

}
}

//Afficher Liste

void afficherListeDbl(PCelluleDbl l)
{
PCelluleDbl p;
p=l;
printf("\n Liste des elements de la liste : ");
while(p!=NULL)
{
printf("\t%d",p->valeur);
p= p->suivant;
}
printf("\n");
}

PCelluleDbl ajouterTeteDbl(PCelluleDbl l, Object* donnee)

{
 PCelluleDbl tete;
tete= malloc(sizeof(PCelluleDbl));
tete->valeur= donnee;
tete->suivant= l;
tete->precedent= NULL;
l->precedent= tete;
return tete;
}

void ajouterQueueDbl(PCelluleDbl liste,Object* donnee)

{
PCelluleDbl queue,p;
p=liste;
queue= malloc(sizeof(PCelluleDbl));
queue->valeur= donnee;
queue->suivant= NULL;

if(p!=NULL)
{
while(p->suivant!=NULL)
{
p=p->suivant;
}
p->suivant= queue;
queue->precedent= p;

void triBulleDbl(PCelluleDbl l)
{
int permut;
PCelluleDbl p,q;

Object* temp;
do{
p=l;
permut=0;
while(p!=NULL)
{
q=p->suivant;
while(q!=NULL)
{
if(p->valeur>q->valeur)
{
permut=1;
temp=p->valeur;
p->valeur=q->valeur;
q->valeur=temp;
}
q=q->suivant;
}
p=p->suivant;
}

}while(permut==1);
}

void InverserListeDbl(PCelluleDbl* l)
{
PCelluleDbl temp, current = *l;
temp=malloc(sizeof(PCelluleDbl));
int step = 0;
 while (current != NULL)
{
if(!step) {
temp->valeur = current->valeur;
temp->suivant = NULL;
}
else {
temp = ajouterTeteDbl(temp, current->valeur);
}
current = current->suivant;
step++;
}
*l = temp;

//*p = r;
}

int nombreEltDbl(PCelluleDbl l,PCelluleDbl *d)

{
int nbre=1;
while(l->suivant!=NULL)
{
nbre++;
}
*d=l;
return nbre;
}

int palindromeDbl(PCelluleDbl l)
{
PCelluleDbl p,premier=l,dernier;
int i,valeurParcours= nombreEltDbl(l,&dernier)/2;

for(i=1;i<valeurParcours;i++)
{

if(premier->valeur!=dernier->valeur)
return 0;
premier=premier->suivant;
dernier=dernier->precedent;
}
return 1;
}

void concatenerListeDbl(PCelluleDbl *l1,PCelluleDbl l2)

{
PCelluleDbl p;
if(*l1==NULL)
{
*l1=l2;
}

else
{
p=*l1;

while(p->suivant!=NULL)
{
p=p->suivant;
}
p->suivant=l2;
l2->precedent=p;
}
}
int rechercherListeDbl(PCelluleDbl l,Object* valeurRechercher,PCelluleDbl *addRecherche)
{
PCelluleDbl p;
int trouver=0;
p=l;
while(trouver==0 && p!=NULL)
{
if(p->valeur==valeurRechercher)
{
trouver=1;
*addRecherche=p;
}
p=p->suivant;
}
return trouver;
}

PCelluleDbl supprimerListeDbl(PCelluleDbl l,Object* donnee)

{
PCelluleDbl p=NULL, preced=NULL;

if(l->valeur==donnee)
{
p=l;
l=l->suivant;
l->precedent=NULL;
free(p);
return l;
}

else
{
if(rechercherListeDbl(l,donnee,&p))
{
preced=p->precedent;
preced->suivant=p->suivant;

if(p->suivant!=NULL) //Verifier si le suivant de P est!= NULL (Au cas où la

cible n'est pas le dernier)
{
p->suivant->precedent=preced;
}
}
}
}

PCelluleDbl supprimerDbl(PCelluleDbl l)
{

void menu() {
printf("\n 1. Creer une liste chaine d'entier\n");
printf(" 2. Ajouter un element en tete de liste\n");
printf(" 3. Ajouter un element en queue de liste\n");
printf(" 4. Trier une liste\n");
printf(" 5. Supprimer un element donne de la liste\n");
printf(" 6. Supprimer les doublons de la liste\n");
printf(" 7. Supprimer le dernier element de la liste\n");
printf(" 8. Fusionner deux listes\n");
printf(" 9. Inverser une liste\n");
printf(" 10. Vérifier si une liste est un palindrome\n");
printf(" 11. Quitter\n");
}
int main()
{
int taille;
int valEnTete,valQue,valSuppr;
PCelluleDbl maListeDbl;
maListeDbl=malloc(sizeof(PCelluleDbl));
int stop = 0;

while(1) {
menu();
printf("Votre choix : "); char reply[4]; fflush(stdin); fgets(reply, 4, stdin);
int integer = atoi(reply);

switch(integer) {
case 0:
printf("Veuillez juste ecrire le numéro correspondant au choix fait.\n");
break;
case 1:
printf("\nVeuillez entrer la taille de la liste : "); fflush(stdin);
scanf("%d",&taille);
CreerListeDbl(maListeDbl,taille);
afficherListeDbl(maListeDbl);
break;
case 2:
printf("\nVeuillez entrer la valeur a ajouter en tete : "); fflush(stdin);
scanf("%d",&valEnTete);
maListeDbl=ajouterTeteDbl(maListeDbl,valEnTete);
afficherListeDbl(maListeDbl);
break;
case 3:
printf("\nVeuillez entrer la valeur a ajouter a la queue : "); fflush(stdin);
scanf("%d",&valQue);
ajouterQueueDbl(maListeDbl,valQue);
afficherListeDbl(maListeDbl);
break;
case 4:
printf("\n =====================TRI DE LA LISTE ==========================");
triBulleDbl(maListeDbl);
afficherListeDbl(maListeDbl);
break;
case 5:
printf("\nVeuillez entrer la valeur a supprimer de la liste : "); fflush(
stdin);
scanf("%d",&valSuppr);
maListeDbl=supprimerListeDbl(maListeDbl,valSuppr);
printf("\n =====================AFFICHAGE DE LA LISTE APRES
SUPPRESSION==========================");
afficherListeDbl(maListeDbl);
break;
case 6:
//supprimer les doublons
break;
case 7:
//supprimer le dernier element de la liste
break;
case 8:
break;
case 9:
printf("\n ====================AFFICHAGE INVERSE DE LA LISTE
==========================");
InverserListeDbl(&maListeDbl);
afficherListeDbl(maListeDbl);
break;
case 10:
//palindrome vérification
break;
 case 11 :
stop = 1;
break;
}

if(stop) {
break;
}
}

return 0;