************************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->[Link]==x)
{
existe=1;
printf("le num %d\n",tmp->[Link]);
printf("le type %s\n",tmp->[Link]);
printf("l etat %s\n",tmp->[Link]);
}
tmp=tmp->suivant;
}
return existe;
}
//affichage d'une liste simplement chainée:
void affichage(liste l)
{
while(l!=NULL)
{
printf("%d->",l->[Link]);
printf("%s->",l->[Link]);
printf("%d->",l->[Link]);
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->[Link]==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;
[Link]=NULL;
[Link]=NULL;
return f;
}
//File vide :
int file_vide(file f)
{
if(([Link]==NULL)&&([Link]==NULL))
return 1;
else
return 0;
}
//Consulter sommet:
int consulter (file f)
{
return(([Link])->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)
{
[Link]=nouv;
[Link]=nouv;
}
else
{
([Link])->suivant=nouv;
[Link]=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);
}
}
