int verifier (liste *tete)

{
if (tete == 0)
return 0;
else
return 1;
}

mlmlmlmlmlmlmlmlmlmlmlmlmlmlmlmlmlmlml

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

struct liste
{
int val;
struct liste *suivant;
};

int verif(struct liste *tete)

{
if (tete == NULL)
{
return 1;
}
else
{
return 0;
}
}

struct liste *ajouterdebut(struct liste *q)

{
struct liste *nouveau = malloc(sizeof(struct liste));
printf(" ------- vous etes entrenne d'ajouter au debut de la liste ");
printf("\n donner la valeur ");
scanf("%d", &(nouveau->val));
nouveau->suivant = q;
return nouveau;
}

struct liste *ajouterfin(struct liste *z)

{
struct liste *nouveaumailon = malloc(sizeof(struct liste));
printf("--- entre le nouveau element a la fin \n");
printf("\n donner la valeur");
scanf("%d", &(nouveaumailon->val));
if (z == NULL)
{
nouveaumailon->suivant = NULL;
z = nouveaumailon;
return nouveaumailon;
}
else
 {
while (z->suivant != NULL)
{
z = z->suivant;
}
nouveaumailon->suivant = NULL;
z->suivant = nouveaumailon;
return z;
}
}

int comptabiliser( struct liste *f)

{
int cpt = 0;
int v =verif(f);
if (v == 1)
{
printf("votr liste est vide ");
return cpt;
}
else
{
struct liste *p;
p = f;
while (p != NULL)
{
cpt++;
p = p->suivant;
}
}

return cpt;
}

void recherche(struct liste *tete)

{ struct liste*ptr=tete;
int s=0;
int x;
printf(" entrer la valeur cherch� ");
scanf("%d",&x);
while (ptr!=NULL){
if (ptr->val==x){
printf("----------element existe----------\n");
s=1;

}
ptr=ptr->suivant;
}
if (s==0){
printf("--------element n'existe pas -----------\n");
}
}

struct liste *ajouteposition(struct liste*h )

{
int i,pos,x;
i=1;
struct liste *nouveau = malloc(sizeof(struct liste));
struct liste *pro=h;
 x=comptabiliser(h);
do {
printf(" entrer la position ou vous voullez ajouter la nouvelle maillon \
n");
scanf("%d",&pos);
} while(pos<1||pos>x+1);

if (pos==1) {
h=ajouterdebut(h);
} else if(pos==(x+1)) {
h= ajouterfin(h);
} else {
printf("entrer la valeure");
scanf("%d",&nouveau->val);
while(i != (pos-1)) {
h=h->suivant;
i=i+1;
}
nouveau->suivant=h->suivant;
h->suivant=nouveau;
}
return h;
}
struct liste* supprimer(struct liste* w)
{
int pos, i, x;
i = 1;

struct liste* o = w;
struct liste* k = w;
x = comptabiliser(w);

do {
printf("Entrer la position que vous voulez supprimer : ");
scanf("%d", &pos);
} while ( (pos < 1) ||( pos > (x + 1)));

if (pos == 1) {
w = w->suivant;
free(o);
return w;
} else {
while (i != pos) {
o = k;
k = k->suivant;
i = i + 1;
}

o->suivant = k->suivant;
free(k);
return w;
}
}

struct liste *creeuneliste(struct liste *l)

{
struct liste *ptr = l;
 char rep[10];
printf("\n\n\n ------------------------------welcome sir you are going now to
build your liste--------------- --------------- \n");
do
{
printf("donner votre nouvelle vaaleur ");
scanf("%d", &ptr->val);
printf("vous voullez continuer? (si oui presse y) ");
scanf("%s", rep);
if ((rep[0] == 'y') || ( rep[0] == 'Y') )
{
ptr->suivant = malloc(sizeof(struct liste));
ptr = ptr->suivant;
}
else
{
ptr->suivant = NULL;
}
} while (rep[0] == 'y' || rep[0] == 'Y');
return l;
}
void afficher(struct liste *r)
{
if (r == NULL)
{
printf("\n\n ------ Listes des valeurs est vide -----\n\n");}
else
{
printf("\n\n ------ Listes des valeurs -----\n\n");
while (r != NULL)
{
printf("* %d * \n", r->val);
r = r->suivant;
}
}
}

struct liste*detruire_liste( struct liste*z)

{
struct liste *n;
while (z != NULL)
{
n = z;
z = z->suivant;
free(n);
}

return NULL;

}
void end(struct liste*r)
{
printf("\n\n\n------- thank you sir that's was great to create this programme
---------\n -----directed by :\n\------");
}
int main()
{

int pos;
int x;
struct liste *tete = NULL;
tete = malloc(sizeof(struct liste));
struct liste *ptr = tete;
tete = creeuneliste(tete);
afficher(tete);
ptr=ajouteposition(ptr);
afficher(tete);
tete = ajouterdebut(tete);
afficher(tete);
ptr = ajouterfin(ptr);
afficher(tete);
x=comptabiliser(tete);
printf(" la taille de votr liste est %d\n",x);

recherche(tete);
tete=supprimer(tete);
afficher(tete);
tete=detruire_liste(tete);
afficher(tete);
end(tete);

return 0;
}

bideractionelle
-----------------------------------------------------------------------------------
----------------------

/*--------------------------------------------- biderectionele
--------------------------------------------------------------------------------*/
/*

void verif(Liste L)
{
if ((L.head==NULL) || (L.taille==0))
printf("la liste est vide \n");
else printf("la liste n'est pas vide \n");
}

void create(Liste *liste)

{
Element *temp,*p;
p=NULL;
temp=NULL;
int i;

for(i=0;i<liste->taille;i++)
{
temp=malloc(sizeof(Element));
 printf("rentrez la valeur de l'element num %d \n ",i+1);
scanf("%d",&temp->valeur);
temp->suivant=NULL;
temp->precedent=NULL;

if (liste->head==NULL)
{
liste->head=temp;

}
else
{
p=liste->head;
if(p->suivant == NULL)
{
p->suivant = temp;
temp->precedent = p;
}
else
{
while (p->suivant!=NULL)
{
p=p->suivant;
}
p->suivant=temp;
temp->precedent=p;
}
}
}
}

void affichage(Liste liste)

{ int i;

Element *p;
p=NULL;
p=liste.head;

for(i=0;i<liste.taille;i++)
{
printf("la valeur de l'element num %d : %d \n",i+1,p->valeur);
p=p->suivant;

if (liste.head==NULL)printf("liste vide \n\n");

}

void ajoutdebut(Liste *liste,int x)

{
Element *q;

q=malloc(sizeof(Element));
q->valeur=x;
q->suivant=NULL;
 q->precedent=NULL;
if (liste->head==NULL) // ou taille = 0;
{
liste->head=q;
}
else
{
q->suivant=liste->head;
liste->head=q;
}
liste->taille=liste->taille+1;
}

void ajoutfin(Liste *liste,int val)

{
Element *p,*q;
q=NULL;
p=NULL;

if (liste->taille == 0)
{
ajoutdebut(liste,val);
}
else
{
q=malloc(sizeof(Element));
q->valeur=val;
q->suivant=NULL;
q->precedent=NULL;
p=liste->head;
while (p->suivant!=NULL)
{
p=p->suivant;
}
p->suivant=q;
q->precedent=p;
liste->taille++;
}
}

void ajoutposition(Liste *liste,int val,int pos)

{

int i;
Element *p,*q,*t;
p=NULL;
q=NULL;
t=NULL;

q=malloc(sizeof(Element));
q->valeur=val;
q->suivant=NULL;

if (pos> liste->taille+1 )
{printf("ERREUR aucun element dans cette position \n\n");
return;}
 else if (pos==1){ajoutdebut(liste,val); return;}
else if (pos==liste->taille+1){ajoutfin(liste,val);return;}
else
{
p=liste->head;
for(i=1;i<pos;i++)
{
t=p;
p=p->suivant;

}
t->suivant=q;
q->precedent=t;
q->suivant=p;
p->precedent=q;
liste->taille++;

}
void trierliste(Liste *liste)
{
int i, j, n, m;
Element *p, *q;

q= NULL;
p= NULL;
n= liste->taille;
q= liste->head;

for (i=0;i<n - 1; i++)

{
p = q->suivant;
for (j = i + 1; j < n; j++)
{
if (p->valeur < q->valeur)
{
m = q->valeur;
q->valeur = p->valeur;
p->valeur = m;
}
p = p->suivant;
}
q = q->suivant;
}
}

void ajout_trie(Liste *liste,int val)

{
Element *p,*q,*r;
p=NULL;
q=NULL;
r=NULL;

if(liste->head->valeur > val || liste->head == NULL)

 {
ajoutdebut(liste,val);
}
else
{ p=liste->head;
q=malloc(sizeof(Element));
q->valeur=val;
q->suivant=NULL;

while((p!=NULL) && (p->valeur < val))

{
r=p;
p=p->suivant;}

if(p==NULL){ajoutfin(liste,val);return;}

q->precedent=r;
p->precedent=q;
r->suivant=q;
q->suivant=p;
liste->taille++;
}

void recherche(Liste liste,int val)

{
Element *p;
bool trouv;
trouv=false;
if (liste.taille == 0)
{
printf("liste vide \n");
return;
}
else
{
p=liste.head;
while(p!=NULL && trouv==false )
{

if (p->valeur==val){trouv=true;}
p=p->suivant;
}
}
if (trouv==true) {printf("l'élement se trouve dans la liste \n");}
else {printf("l'élement ne se trouve pas dans la list \n ");}
}

void compter(Liste liste)

{
int s;
Element *p;
p=NULL;
p=liste.head;
s=0;
while(p!=NULL)
{
 p=p->suivant;
s=s+1;
}
printf("nombre d'elements : %d \n\n",s);
}

void detruire(Liste *liste)

{ int i;
Element *p,*q;
p=liste->head;
for(i=0;i<liste->taille;i++)
{ q=p;
p=p->suivant;
free(q);
}
liste->head=NULL;
liste->taille=0;

void supppos(Liste *liste, int pos)

{ Element *p,*q;
if (liste->taille==0||pos >liste->taille) {
printf("ERREUR : position invalide\n\n");
return;
}

p=liste->head;
if (pos==1) {
liste->head=p->suivant;
if (liste->head!=NULL) {
liste->head->precedent=NULL;
}
free(p);
} else {
q=NULL;
int i;
for (i=1;i<pos;i++) {
q=p;
p=p->suivant;
}
q->suivant=p->suivant;
if (p->suivant!=NULL) {
p->suivant->precedent=q;
}
free(p);
}
liste->taille--;
}
*/