Autorise

************************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:

{
int val ;
}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:

{
int val ;
}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);
ParcoursInfixe(R->FD);
}
}
void ParcoursPostfixe(Arbre R)
{
if (R!=NULL)
{
ParcoursPostfixe(R->FG);
ParcoursPostfixe(R->FD);
}
}

Autorise

Transféré par

Droits d'auteur :

Formats disponibles

Autorise

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Autorise

Transféré par

Droits d'auteur :

Formats disponibles

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

typedef struct 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)

liste ajouterdeb(liste l, wagon w)

liste ajouterfin(liste l, wagon w)

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

int recherche(liste l,int x)

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

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

typedef struct cellule

typedef cellule *pile;

//Fonction tester pile vide:

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

pile empiler (pile p,int x)

pile depiler (pile p)

typedef struct cellule

typedef struct file

int consulter (file f)

file enfiler(file f,int x)

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

int defiler(file *f)

Vous aimerez peut-être aussi

**Les Listes simplement chaînées *