************************Les Listes simplement chaînées ***********************

//Declaration fel .h :

typedef struct
{
int num;
char type [20];
int etat;
} wagon;

typedef struct cellule

{
wagon w;
struct cellule *suivant;
} cellule;

typedef struct cellule *liste;

//la saisie de l'enregistrement et l'ajout au debut et a la fin de la liste :

void saisir( wagon *w)

{
printf("*donner les details de la liste*\n");
printf("donner le numero\n");
scanf("%d",&w->num);
printf("donner le type\n");
scanf("%s",w->type);
printf("donner l etat\n");
scanf("%d",&w->etat);
}

liste ajouterdeb(liste l, wagon w)

{
cellule* nouv;
nouv = (cellule*) malloc(sizeof(cellule));
nouv->w=w;
nouv->suivant=NULL;
if(l==NULL)
{
l=nouv;
}
else
{
nouv->suivant=l;
l=nouv;
}

return(l);
}

liste ajouterfin(liste l, wagon w)

{
cellule * nouv, *p;

nouv = (cellule*) malloc(sizeof(cellule));

nouv->w=w;
nouv->suivant=NULL;
 if(l==NULL)
{
l=nouv;
}
else
{
p=l;
while(p->suivant!=NULL)
p=p->suivant;

p->suivant = nouv;
}
return(l);
}

//Rechercher dans une liste simplement chainée retourne 1 si existe 0 sinon avec
l'affichage:

int recherche(liste l,int x)

{int existe =0;
struct cellule*tmp;
tmp=l;
while(tmp!=NULL)
{
if (tmp->l.num==x)
{
existe=1;
printf("le num %d\n",tmp->t.num);
printf("le type %s\n",tmp->t.type);
printf("l etat %s\n",tmp->t.etat);

}
tmp=tmp->suivant;
}
return existe;
}

//affichage d'une liste simplement chainée:

void affichage(liste l)
{
while(l!=NULL)
{
printf("%d->",l->l.num);
printf("%s->",l->l.type);
printf("%d->",l->l.etat);
l=l->suivant;
}

//supprimer les wagon qui ont l'etat en pannne(=0):

liste Supprimerwagon(liste l)
{
 cellule *temp,*sup,*prec;

if (l!=NULL)
{
prec=l;
temp=l->suivant;
while(temp!=NULL)
{
while(temp!=NULL&&temp->wag.etat==0)
{
sup=temp;
temp=temp->suivant;
prec->suivant=temp;
free(sup);
}
if (temp!=NULL)
{
prec=temp;
temp=temp->suivant;
}
}
}
else
{
printf("liste vide\n");
}

return l;
}

***********************************PILE*******************************************
//Déclaration:

typedef struct cellule

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

typedef cellule *pile;

//Fonction tester pile vide:

int pile_vide(pile p)
{
if(p==NULL)
return 1;
else
return 0;
}

//Fonction consulter la sommet de la pile et retoune sa valeur

int consulter(pile p)
{
if(pile_vide(p)==0)
return p->val;
}

//EMPILER:

pile empiler (pile p,int x)

{ pile nouv;

nouv=malloc(sizeof(cellule));
nouv->val=x;
nouv->suivant=p;
p=nouv;
return p;
}

//DEPILER:

pile depiler (pile p)

{ pile suppr;

if(pile_vide(p)==0)
{
suppr=p;
p=p->suivant;
free(suppr);
}
else
{
printf("PILE VIDE !\n);
}

return p;
}

********************************************FILE***********************************
********

//Déclaration:

typedef struct cellule

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

typedef struct file

{
Cellule *tete;
Cellule *queue;
}file;

//Initialisation de la file:
 file initialiser()
{
file f;
f.tete=NULL;
f.queue=NULL;
return f;
}

//File vide :

int file_vide(file f)
{
if((f.tete==NULL)&&(f.queue==NULL))
return 1;
else
return 0;
}

//Consulter sommet:

int consulter (file f)

{
return((f.tete)->val);
}

//ENFILER:

file enfiler(file f,int x)

{
cellule *nouv;

nouv=malloc(sizeof(cellule));
nouv->val=x;
nouv->suivant=NULL;

if(file_vide(f)==1)
{
f.tete=nouv;
f.queue=nouv;
}
else
{
(f.queue)->suivant=nouv;
f.queue=nouv;
}
return f;
}

//DEFILER permet de defiler un element en tete et retourne la valeur de l'element

defiler:

int defiler(file *f)

{
int valeur;
if(file_vide(*f)==1)
printf("file vide rien a defiler !\n");
 else
{
cellule *elem= f->tete;
valeur=elem->val;
f->tete=elem->suivant;
if(f->tete==NULL)
f->queue=NULL;
free(elem);
}
return valeur;
}

**************************************ABR***************************************
void ParcoursPrefixe(Arbre R)
{
if (R!=NULL)
{
printf("\n Racine = %d", R->X);
ParcoursPrefixe(R->FG);
ParcoursPrefixe(R->FD);
}
}

void ParcoursInfixe(Arbre R)
{
if (R!=NULL)
{
ParcoursInfixe(R->FG);
printf("\n Racine = %d", R->X);
ParcoursInfixe(R->FD);
}
}

void ParcoursPostfixe(Arbre R)
{
if (R!=NULL)
{
ParcoursPostfixe(R->FG);
ParcoursPostfixe(R->FD);
printf("\n Racine = %d", R->X);
}
}