Structures donneenew

Structures des données Année universitaire : 2010/2011
Lajouad Rachid 1/18
I) Liste simplement chaînée
1) INTRODUCTION
Ce document a pour but la compréhension des listes simplement chaînées. L'implémentation en fonction des besoins et des performances vous appartient. Les listes chaînées peuvent être utilisées quand plusieurs opérations d'insertion/suppression d'éléments sont nécessaires.
2) Définition
Les listes chaînées sont des structures de données semblables aux tableaux sauf que l'accès à un élément ne se fait pas par index mais à l'aide d'un pointeur. L'allocation de la mémoire est faite au moment de l'exécution. Dans une liste les éléments sont contigus en ce qui concerne l'enchaînement.
En revanche, par rapport aux tableaux où les éléments sont contigus dans la mémoire, les éléments d'une liste sont éparpillés dans la mémoire. La liaison entre les éléments se fait grâce à un pointeur. En réalité, dans la mémoire la représentation est aléatoire en fonction de l'espace alloué. Le pointeur suivant du dernier élément doit pointer vers NULL (la fin de la liste). Pour accéder à un élément la liste est parcourue en commençant avec la tête, le pointeur suivant permettant le déplacement vers le prochain élément. Le déplacement se fait dans une seule direction, du premier vers le dernier élément.
3) La construction du prototype d'un élément de la liste
Pour définir un élément de la liste le type struct sera utilisé. L'élément de la liste contiendra un champ donné et un pointeur suivant. Le pointeur suivant doit être du même type que l'élément, sinon il ne pourra pas pointer vers l'élément. Le pointeur "suivant" permettra l'accès vers le prochain élément. typedef struct ElementListe { float Data; struct ElementListe *suivant; }Element;
Remarque :
Pour avoir le contrôle de la liste il est préférable de sauvegarder certains éléments : Le premier élément, le dernier élément, le nombre d'éléments. Pour réaliser cela une autre structure sera utilisée (ce n'est pas obligatoire, des variables peuvent être utilisées).
Voici sa composition: typedef struct ListeRepere { Element *debut; Element *fin; int taille; }Liste; donnée
Suivant donnée
Suivant donnée
Suivant
Debut
Fin
NULL

Lajouad Rachid 2/18
- Le pointeur debut contiendra l'adresse du premier élément de la liste.
- Le pointeur fin contiendra l'adresse du dernier élément de la liste.
- La variable taille contient le nombre d'éléments.
- Quelque soit la position dans la liste, les pointeurs debut et fin pointent toujours respectivement vers le 1er et le dernier élément.
- Le champ taille contiendra le nombre d'éléments de la liste quelque soit l'opération effectuée sur la liste.
4) Opérations sur les listes chaînées
Pour l'insertion ainsi que pour la suppression, une seule fonction est largement suffisante si elle est bien conçue en fonction des besoins.
Toutefois je vous rappelle que cet article est purement didactique.
C'est la raison pour laquelle j'ai écrit une fonction pour chaque opération d'insertion et de suppression.
a) Initialisation
A l’initial la liste doit être positionnée sur NULL (une liste ne contenant aucun élément.
Prototype de la fonction :
Element *initialisation ();
La fonction
Element *initialisation (){ return NULL; }
Si on utilisait la structure repère pour le contrôle de la liste et pour sauvegarder le début la fin et la taille on doit initialiser cette structure en utilisant une fonction supplémentaire d’initialisation.
void init (Liste *liste);
Cette opération doit être faite avant toute autre opération sur la liste.
Elle initialise le pointeur debut et le pointeur fin avec le pointeur NULL, et la taille avec la valeur 0.
La fonction
void init (Liste *liste){ liste->debut = NULL; liste->fin = NULL; taille = 0; }
b) Insertion d'un élément dans la liste
Voici l'algorithme d'insertion et de sauvegarde des éléments :
 déclaration d'élément(s) à insérer
 allocation de la mémoire pour le nouvel élément
 remplir le contenu du champ de données
 mettre à jour les pointeurs vers le 1er et le dernier élément si nécessaire.
o Cas particulier : dans une liste avec un seul élément, le 1er est en même temps le dernier.
o mettre à jour la taille de la liste
Pour ajouter un élément dans la liste il y a plusieurs situations :
 Insertion au début de la liste
 Insertion à la fin de la liste
 Insertion ailleurs dans la liste

Lajouad Rachid 3/18
Insertion au début de la liste
Element *InsDebut (Element *liste, float x);
Etapes :
 remplir le champ de données du nouvel élément
 le pointeur suivant du nouvel élément pointera vers L’entête de la liste sinon vers NULL (si la liste est vide)
La fonction Element *InsDebut(Element * liste, float x){ Element *NewElem; NewElem = (Element *) malloc (sizeof (Element)); NewElem->Data = x; NewElem->suivant = liste; /*Remarque bien que liste représente l’entete */ return NewElem; /*NewElem représente maintenant le nouveau entête*/ }
c) Insertion à la fin de la liste
Element *InsFin(Element *liste, float donnee);
Étapes:
 le pointeur suivant du dernier élément pointe vers le nouvel élément
 le pointeur debut ne change pas sauf si la liste est vide.
La fonction Element *InsFin(Element * liste, float donnee){ Element *NewElem; NewElem = (Element*) malloc (sizeof (Element)); NewElem->Data = donnee ; NewElem->suivant = NULL ; if (liste == NULL) return NewElem; /* sinon il faut rechercher la queue de la liste */ Element *Queue = liste ; While (Queue->suivant != NULL) Queue = Queue->suivant ; Queue->suivant = NewElem ; donnée
Suivant
Liste
Debut
Element Crée
Debut
Liste
Debut donnée
Suivant
Element Crée
NULL

Lajouad Rachid 4/18
return liste; }
d) Insertion ailleurs dans la liste
Element *InsA (Element *liste, float *donnee, int pos);
L'insertion s'effectuera après une certaine position passée en argument à la fonction.
Si la position indiquée ne doit pas être le dernier élément. Dans ce cas il faut utiliser la fonction d'insertion à la fin de la liste.
Étapes:
 choisir une position dans la liste (l'insertion se fera après la position choisie)
 le pointeur suivant du nouvel élément pointe vers l'adresse sur laquelle pointe le pointeur suivant d'élément courant.
 le pointeur suivant du l'élément courant pointe vers le nouvel élément
 le pointeur debut ne change pas
La fonction
Element *InsA (Element * liste, float *donnee, int pos){ if( pos == 1) return InsDebut(liste, donnee); if( pos >= longueur(liste)) return InsFin(liste, donnee); Element *NewElem = (Element*) malloc (sizeof(Element)) ; NewElem->Data = donnee; Element *Pos = liste; for (int i=1; i<pos; i++) Pos = Pos->suivant; newElem->suivant = Pos->suivant; Pos->suivant = NewElem; return liste; }
e) Longueur d’une liste :
int Longueur ( Element *liste) ;
La fonction : int Longueur(Element*liste){ int lon=0 ; while(liste != NULL) { liste = liste->suivant ;lon++ ;}
Liste
Debut donnée
Suivant
Element Crée
NULL donnée
Suivant donnée
Suivant
Liste
1
2

Lajouad Rachid 5/18
return lon ; }
f) Suppression d'un élément dans la liste
Voici l'algorithme de suppression d'un élément de la liste :
 utilisation d'un pointeur temporaire pour sauvegarder l'adresse d'éléments à supprimer
 l'élément à supprimer se trouve après l'élément courant
Faire pointer le pointeur suivant de l'élément courant vers l'adresse du pointeur suivant de l'élément à supprimer
 libérer la mémoire occupée par l'élément supprimé
Pour supprimer un élément dans la liste il y a plusieurs situations :
 Suppression au début de la liste
 Suppression à la fin de liste.
 Suppression ailleurs dans la liste
g) Suppression au début de la liste
Prototype de la fonction:
Element *SuppDebut (Element *liste);
Étapes:
 le pointeur supp_elem contiendra l'adresse du 1er élément
 le pointeur debut pointera vers le 2ème élément
 Libérer la mémoire utilisée par l’élément supprimé.
La fonction
Element *SuppDebut (Element *liste){ if (liste == NULL) return NULL; Element *l = liste; Liste = liste->suivant; free(l); return liste; }
h) Suppression à la fin de la liste
Prototype de la fonction: Element *SuppFin (Element *liste);
Étapes:
 le pointeur supp_elem contiendra l'adresse du dernier élément
 le pointeur debut pointera vers le 1er élément
 L’élément avant dernier pointe vers NULL.
 Libérer la mémoire utilisée par l’élément supprimé.
La fonction Element *SuppFin (Element *liste){ if (liste == NULL) return NULL; if (liste->suivant == NULL) { free(liste); return NULL;} Element *ld,*l = liste; While(l->suivant->suivant !=NULL) l=l->suivant ; ld = l->suivant; l->suivant = NULL ; free(ld); return liste; }

Lajouad Rachid 6/18
i) Suppression ailleurs dans la liste
Prototype de la fonction:
Element *SuppPos (Element *liste, int pos);
Étapes:
 le pointeur sur l’élément à supprimer contiendra l'adresse vers laquelle pointe le pointeur suivant d'élément courant
 le pointeur suivant de l'élément courant pointera vers l'élément sur lequel pointe le pointeur suivant de l'élément qui suit l'élément courant dans la liste
Si l'élément courant est l'avant dernier élément, le pointeur fin doit être mis à jour
La fonction Element *SuppPos(Element * liste, int pos){ if (liste == NULL) return NULL ; if (pos == 1) return SuppDebut(liste); if (pos >= longueur(liste)) return SuppFin(liste); Element *dl, *l = liste; for(int i=1; i < pos; i++) l = l->suivant; dl = l->suivant; l->suivant = dl->suivant; free(dl); return liste; }
j) Affichage de la liste
Pour afficher la liste entière il faut se positionner au début de la liste. Ensuite en utilisant le pointeur suivant de chaque élément la liste est parcourue du 1er vers le dernier élément. La condition d'arrêt est donnée par le pointeur suivant du dernier élément qui vaut NULL.
La fonction void affiche (Element * liste){ while (liste != NULL){ printf ("%p - %.2fn", liste, liste->Data); liste = liste->suivant; } }
k) Destruction de la liste
Pour détruire la liste entière, on utilise la suppression au début de la liste tant que la taille est plus grande que zéro.
La fonction void detruire (Element * liste){ while (longueur(liste) > 0) liste = SuppDebut(liste); }

Lajouad Rachid 7/18
II) Liste doublement chaînée
1) INTRODUCTION
Ce document a pour but la compréhension des listes doublement chaînées.
L'implémentation en fonction des besoins et des performances vous appartient.
Les listes doublement chaînées peuvent être utilisées quand plusieurs opérations d'insertion/suppression d'éléments sont nécessaires.
2) Définition
Les listes doublement chaînées sont des structures de données semblables aux listes simplement chaînées . L'allocation de la mémoire est faite au moment de l'exécution.
En revanche, par rapport aux listes simplement chaînées la liaison entre les éléments se fait grâce à deux pointeurs (un qui pointe vers l'élément précédent et un qui pointe vers l'élément suivant).
Le pointeur precedent du premier élément doit pointer vers NULL (le début de la liste). Le pointeur suivant du dernier élément doit pointer vers NULL (la fin de la liste). Pour accéder à un élément la liste peut être parcourue dans les deux sens :
 en commençant avec la tête, le pointeur suivant permettant le déplacement vers le prochain élément.
 en commençant avec la queue, le pointeur precedent permettant le déplacement vers l'élément précédent.
En bref, le déplacement se fait dans les deux directions, du premier vers le dernier élément et/ou du dernier vers le premier élément.
3) La construction du prototype d'un élément de la liste
Pour définir un élément de la liste le type struct sera utilisé. L'élément de la liste contiendra un champ donnee, un pointeur precedent et un pointeur suivant. Les pointeurs precedent et suivant doivent être du même type que l'élément, sinon ils ne pourront pas pointer vers un élément de la liste. Le pointeur "precedent" permettra l'accès vers l'élément précédent tandis que le pointeur suivant permettra l'accès vers le prochain élément. typedef struct ElementListe { float Data; struct ElementListe *precedent; struct ElementListe *suivant; }Element;
4) Opérations sur les listes doublement chaînées
Pour l'insertion ainsi que pour la suppression, une seule fonction est largement suffisante si elle est bien conçue en fonction des besoins. Toutefois je vous rappelle que ce document est purement didactique. C'est la raison pour laquelle j'ai écrit une fonction pour chaque opération d'insertion et de suppression.
Debut
Fin
NULL donnée
Suivant
Precedant donnée
Suivant
Precedant donnée
Suivant
Precedant
NULL

Lajouad Rachid 8/18
a) Initialisation
Initialement la liste est vide donc il n’y a que le NULL
Cette opération doit être faite avant toute autre opération sur la liste. La fonction Element *initialisation (){ return NULL ; }
b) Insertion d'un élément dans la liste
 mettre à jour les pointeurs vers l'élément précédent et l'élément suivant
 mettre à jour les pointeurs vers le 1er et le dernier élément si nécessaire.
o Cas particulier : dans une liste avec un seul élément, le 1er est en même temps le dernier.
Pour ajouter un élément dans la liste il y a plusieurs situations :
 Insertion au début de la liste
 Insertion à la fin de la liste
 Insertion à une position quelconque.
c) Insertion au début de la liste
Element *InsDebut(Element * liste, float donnee);
Étapes :
 le pointeur precedent du nouvel élément pointera vers NULL
 le pointeur suivant du nouvel élément pointera vers NULL si la liste est vide et sur le premier chaînon sinon.
La fonction Element *InsDebut(Element * liste, float donnee) { Element *NewElem = (Element*)malloc(sizeof(Element)); NewElem->Data = donnee; NewElem->precedent = NULL; if (liste == NULL) { NewElem->suivant = NULL; return NewElem; } while(liste->precedent != NULL) liste = liste->precedent; liste->precedent = NewElem; NewElem->suivant = liste; return NewElem; }
d) Insertion à la fin de la liste

Lajouad Rachid 9/18
Element *InsFin(Element * liste, float donnee) ;
Étapes:
 le pointeur suivant du nouvel élément pointe vers NULL
 le pointeur précédent du nouvel élément pointe vers le dernier élément
 le pointeur suivant du dernier élément va pointer vers le nouvel élément
La fonction Element *InsFin(Element * liste, float donnee) { Element *NewElem = (Element*)malloc(sizeof(Element)); NewElem->Data = donnee; NewElem->suivant = NULL; if (liste == NULL) { NewElem->precedent = NULL; return NewElem; } while(liste->suivant != NULL) liste = liste->suivant; liste->suivant = NewElem; NewElem->precedent = liste; return NewElem; }
e) Insertion a une position quelconque de la liste
Element *InsPos(Element *liste, float donnee, int pos);
L'insertion s'effectuera avant une certaine position passée en argument à la fonction. La position indiquée ne doit pas être ni le 1er ni le dernier élément. Dans ce cas il faut utiliser les fonctions d'insertion au début et/ou à la fin de la liste.
Étapes:
 choisir une position dans la liste (l'insertion se fera après la position choisie)
 le pointeur suivant du nouvel élément pointe vers l'élément courant.
 le pointeur precedent du nouvel élément pointe vers l'adresse sur la quelle pointe le pointeur precedent d'élément courant.
 le pointeur suivant de l'élément qui précède l'élément courant pointera vers le nouveau élément
 le pointeur precedent d'élément courant pointe vers le nouvel élément
La fonction Element *InsPos(Element * liste, float donnee, int pos) { if(pos <= 1) return InsDebut(liste, donnee); if(pos >= longueur(liste)) return InsFin(liste, donnee); Element *NewElem = (Element*)malloc(sizeof(Element)); NewElem->Data = donnee; while(liste->precedant != NULL) liste = liste->precedant; for(int i = 1; i < pos; i++) liste = liste->suivant NewElem->suivant = liste; NewElem->precdant = liste->precedent; liste->precedent->suivant = NewElem; liste->precedent = NewElem; return liste; }

Lajouad Rachid 10/18
f) Suppression d'un élément dans la liste
Voici l'algorithme de suppression d'un élément de la liste :
 utilisation d'un pointeur temporaire pour sauvegarder l'adresse d'éléments à supprimer
 l'élément à supprimer peut se trouver dans n'importe quelle position dans la liste.
Par rapport aux listes simplement chaînées où la suppression ne peut pas être faite qu'après un élément désigné, les listes doublement chaînées sont plus maniables grâce aux 2 pointeurs qui permettent de garder une trace en arrière comme en avant.
 libérer la mémoire occupée par l'élément supprimé
Pour supprimer un élément dans la liste il y a plusieurs situations :
 Suppression au début de la liste
 Suppression à la fin de la liste
 Suppression d'un élément
Toutefois, la suppression au début et à la fin de la liste doublement chaînées ainsi qu'avant ou après un élément revient à la suppression à la position 0 (zéro) ou à la position N (N = nombre d'éléments de la liste) ou ailleurs dans la liste.
Dans le cas des listes doublement chaînées la suppression à n'importe quelle position ne pose pas des problèmes grâce aux pointeurs précédent et suivant, qui permettent de garder la liaison entre les éléments de la liste. C'est la raison pour la quelle nous allons créer une seule fonction.
 si nous voulons supprimer l'élément au début de la liste nous choisirons la position zéro
 si nous voulons supprimer l'élément à la fin de la liste nous choisirons la position N (le nombre d'éléments)
 si nous désirons supprimer un élément quelconque alors on choisit sa position dans la liste
Suppression dans la liste
Element *Supp(Element *liste, int pos);
Nous distinguons plusieurs situations :
 suppression à la position 1 dans une liste avec un seul élément
 suppression à la position 1 dans une liste avec plusieurs éléments
 suppression à la dernière position (le dernier élément)
 suppression ailleurs dans la liste à une certaine position
La suppression dans une liste vide n'a pas de sens. Étapes:
 la position choisie est 1 (le cas de suppression du 1er élément de la liste)
o le pointeur supp_element contiendra l'adresse du 1er élément
o le pointeur debut contiendra l'adresse contenue par le pointeur suivant du 1er élément que nous voulons supprimer (si ce pointeur vaut NULL alors nous mettons à jour le pointeur fin puisqu'on est dans le cas d'une liste avec un seul élément, sinon nous faisons pointer le pointeur precedent du 2ème élément vers NULL)
 la position choisie est égale avec le nombre d'éléments de la liste
o le pointeur supp_element contiendra l'adresse du dernier élément
o nous faisons pointer le pointeur suivant de l'avant dernier élément (c'est l'élément vers le quel pointe le pointeur <precedent> de dernier élément), vers NULL
o nous mettons à jour le pointeur fin
 la position choisie est aléatoire dans la liste
o le pointeur supp_element contiendra l'adresse de l'élément à supprimer

o le pointeur suivant d'élément qui précède l'élément à supprimer pointe vers l'adresse contenu par le pointeur suivant d'élément à supprimer
o le pointeur precedent d'élément qui succède l'élément à supprimer pointe vers l'adresse contenu par le pointeur precedent d'élément à supprimer.
o la taille de la liste sera décrémentée d'un élément
La fonction
/*Suppression de l’entête*/
Element *SuppTete(Element*liste) {
if(liste == NULL) return NULL ;
while(liste->precedent != NULL)liste = liste->precedent;
Element *Dl = liste;
liste->suivant->precedent = NULL;
liste = liste->suivant;
free(Dl) ;
return liste ; }
/*Suppression de la fin de la liste */
Element *SuppFin(Element*liste) {
if(liste == NULL) return NULL ;
while(liste->suivant != NULL)liste = liste->suivant;
Element *Dl = liste;
liste->precedent->suivant = NULL;
liste = liste->precedent;
free(Dl) ;
return liste ; }
/*Suppression à une position quelconque */
Element *SuppOther(Element*liste, int pos) {
if(pos <= 1)
return SuppTete(liste);
if(pos >= longueur(liste))
return SuppFin(liste);
while(liste->precedent != NULL)liste = liste->precedent ;
for(int i = 1 ; i < pos-1 ; i++) liste = liste->suivant ;
/*Nous somme maintenant avant l’element à supprimer */
Element *Tempo = liste->suivant ;
liste->suivant = Tempo->suivant ;
Tempo->suivant->precedent = liste ;
free(tempo) ;
return liste ; }
g) Affichage de la liste
Pour afficher la liste entière nous pouvons nous positionner au début de la liste ou à la fin de la liste. Ensuite en utilisant le pointeur suivant ou precedent de chaque élément la liste est parcourue du 1er vers le dernier élément ou du dernier vers le 1er élément. La condition d'arrêt est donnée par le pointeur suivant du dernier élément qui vaut NULL dans le cas de la lecture du début vers la fin de liste, ou par le pointeur precedent du 1er élément qui vaut NULL, dans le cas d'une lecture de la fin vers le début de la liste. Les fonctions
void affiche(Element *liste){ /* affichage en avançant */
if(liste != NULL) {
while(liste->precdent != NULL) liste = liste->precedent ;
while(liste != NULL) {
printf(" %.2f n", liste->Data) ;
liste = liste->suivant ;
}
}
}
h) Destruction de la liste

Pour détruire la liste entière, on peut utiliser la suppression à la position 1 tant que la taille est plus grande que zéro. La fonction void detruire(Element *liste){ while(longueur(liste)> 0) liste = suppTete(liste,1); }
III) Les piles en langage C
1) INTRODUCTION
Ce document a pour but la compréhension des piles. L'implémentation en fonction du besoin vous appartient. Pour expliquer l'algorithme j'ai choisi d'utiliser une liste simplement chaînée. Donc la compréhension des listes chaînées est nécessaire.
2) Définition
La pile est une structure de données, qui permet de stocker les données dans l'ordre LIFO (Last In First Out) - en français Dernier Entré Premier Sorti). La récupération des données sera faite dans l'ordre inverse de leur insertion. Pour l'implémentation on peut choisir une liste simplement chaînée. L'insertion se faisant toujours au début de la liste, le 1er élément de la liste sera le dernier élément saisi, donc sa position est en haut de la pile. Ce qui nous intéresse c'est que le dernier élément entré, sera le 1er élément récupéré.
3) La construction du prototype d'un élément de la pile
Pour définir un élément de la pile le type struct sera utilisé. L'élément de la pile contiendra un champ donnee et un pointeur suivant. Le pointeur suivant doit être du même type que l'élément, sinon il ne pourra pas pointer vers l'élément. Le pointeur suivant permettra l'accès vers le prochain élément.
typedef struct ElementListe {
float Data;
struct ElementListe *suivant;
} Element;
Pour permettre les opérations sur la pile, on peut sauvegarder certains éléments :
 le premier élément
 le nombre d'éléments
Le 1er élément, qui se trouve en haut de la pile, nous permettra de réaliser l'opération de récupération des données situées en haut de la pile.
4) Opérations sur les piles
a) Initialisation
Cette opération doit être faite avant toute autre opération sur la pile. Elle initialise le pointeur debut avec le pointeur NULL, et la taille avec la valeur 0.
La fonction
Debut
NULL donnée
Suivant donnée
Suivant donnée
Suivant

Element *initialisation () { return NULL; }
b) Insertion d'un élément dans la pile
Voici l'algorithme d'insertion et de sauvegarde des éléments : C’est le même algorithme d’ajout à l’entête d’une liste simplement chaînée.
Dans cette partie on s’entraînera sur une nouvelle approche d’empilement (et ceci en utilisant une passation d’argument par référence).
void empiler(Element **tas, float donnee);
La fonction /* empiler (ajouter) un élément dans la pile */ void empiler(Element **tas, float donnee) { Element *NewElem = (Element*) malloc ( sizeof ( Element )); NewElemn->Data = donnee; NewElem->suivant = *tas; *tas = NewElem; }
c) Dépilement de la pile
Pour supprimer (ôter ou dépiler) l'élément de la pile, il faut tout simplement supprimer l'élément vers lequel pointe le pointeur debut. Cette opération permet de récupérer la donnée en haut de la pile, et de la supprimer. Prototype de la fonction :
float depiler (Element **tas);
Les étapes :
- Un pointeur temporaire contiendra l'adresse du 1er élément
- le pointeur de début pointera vers le 2ème élément.
- On retourne la valeur de l’élément et on libère la mémoire occupée par cet élément.
La fonction float depiler (Element **tas){ if(*tas == NULL) { printf(" pile viden"); return -1; } Element *tempo = *tas; *tas = (*tas)->suivant; float res = tempo->Data; free(tempo); return res; }
d) Lire la valeur à l’entête de la pile
float Tete (Element *tas);
Les étapes :
- Lire la valeur à l’entête de la pile.
- Retourner la valeur lû.
La fonction float Tete (Element *tas){ if(tas == NULL) {

printf(" pile viden"); return -1; } return (tas->Data) ; }
e) Hauteur de la pile :
int Hauteur (Element *tas);
Les étapes :
- Un compteur est initialisé à zero.
- On commence à parcourir la pile tout en incrémentant le compteur.
- On retourne la valeur du compteur.
La fonction float Hauteur (Element *tas){ int cpt = 0 ; while(tas != NULL) { tas = tas->suivant ; cpt++ ; } return cpt; }

IV) Les files en langage C
1) INTRODUCTION
Ce document a pour but la compréhension des files. L'implémentation en fonction du besoin vous appartient. Pour expliquer l'algorithme on peut utiliser une liste simplement chaînée.
2) Définition
La file est une structure de données, qui permet de stocker les données dans l'ordre FIFO (First In First Out - en français Premier Entré Premier Sorti). La récupération des données sera faite dans l'ordre d'insertion. L'insertion dans la file se fera dans l'ordre normal, le 1er élément de la file sera le premier élément saisi, donc sa position est au début de la file.
3) La construction du prototype d'un élément de la file
Pour définir un élément de la file le type struct sera utilisé. L'élément de la file contiendra un champ donnee et un pointeur suivant. Le pointeur suivant doit être du même type que l'élément, sinon il ne pourra pas pointer vers l'élément. Le pointeur suivant permettra l'accès vers le prochain élément.
typedef struct ElementListe {
float Data;
struct ElementListe *suivant;
}Element;
4) Opérations sur les files
a) Initialisation
void initialisation (Element **file);
Cette opération doit être faite avant toute autre opération sur la file. Elle l’initialise sur le pointeur NULL. La fonction void initialisation (Element **file){ *file = NULL ; } donnée
Suivant donnée
Suivant donnée
Suivant
Debut
Fin
NULL

b) Insertion d'un élément dans la file
 mettre à jour le pointeur debut vers le 1er élément (le début de file)
void enfiler (Element ** suite, float donnee);
C’est la même fonction d’empilement dans une pile.
La fonction /* empiler (ajouter) un élément dans la pile */ void efiler(Element **suite, float donnee) { Element *NewElem = (Element*) malloc ( sizeof ( Element )); NewElemn->Data = donnee; if(*suite == NULL) { NewElem->suivant = NULL; *suite = NewElem; } else { NewElem->suivant = *suite; *suite = NewElem; } }
c) Défilement de la file
Pour supprimer (ôter ou dépiler) l'élément de la file, il faut tout simplement supprimer le dernier élément de liste chaîné. Cette opération permet de récupérer la donnée en queue de la file, et de la supprimer. Prototype de la fonction :
float defiler (Element **suite);
Les étapes :
- Un pointeur temporaire contiendra l'adresse du dernier élément
- le pointeur suivant de cet élément pointera sur NULL.
- Le dernier élément est libéré de la mémoire après avoir retourner la valeur incluse. t.
La fonction float defiler (Element **suite){ if(*suite == NULL) { printf(" file viden"); return -1; } Element *ptrf = *suite; float res; if(ptrf->suivant == NULL) { res = ptrf->Data; initialisation(*suite);} else { while(ptrf->suivant->suivant != NULL) ptrf = ptrf->suivant; res = ptrf->suivant->Data; free(ptrf->suivant); ptrf->suivant = NULL; } return res; }
d) Lire la valeur cible (à la queue) de la file
float Queue (Element **suite);

Les étapes :
- Lire la valeur à l’entête de la pile.
- Retourner la valeur lû.
La fonction float Queue (Element *suite){ if(suite == NULL) { printf(" file viden"); return -1; } while(suite->suivant != NULL) suite = suite->suivant; return (suite->Data) ; }
e) Longueur de la file :
int Longueur (Element *suite);
Les étapes :
- Un compteur est initialisé à zero.
- On commence à parcourir la file tout en incrémentant le compteur.
- On retourne la valeur du compteur.
La fonction float Longueur (Element *suite){ int cpt = 0 ; while(suite != NULL) { suite = suite->suivant ; cpt++ ; } return cpt; }

TABLE DES MATIERES :
I) LISTE SIMPLEMENT CHAINEE 1
1) INTRODUCTION 1
2) DEFINITION 1
3) LA CONSTRUCTION DU PROTOTYPE D'UN ELEMENT DE LA LISTE 1
4) OPERATIONS SUR LES LISTES CHAINEES 2
A) INITIALISATION 2
B) INSERTION D'UN ELEMENT DANS LA LISTE 2
C) INSERTION A LA FIN DE LA LISTE 3
D) INSERTION AILLEURS DANS LA LISTE 4
E) LONGUEUR D’UNE LISTE : 4
F) SUPPRESSION D'UN ELEMENT DANS LA LISTE 5
G) SUPPRESSION AU DEBUT DE LA LISTE 5
H) SUPPRESSION A LA FIN DE LA LISTE 5
I) SUPPRESSION AILLEURS DANS LA LISTE 6
J) AFFICHAGE DE LA LISTE 6
K) DESTRUCTION DE LA LISTE 6
II) LISTE DOUBLEMENT CHAINEE 7
1) INTRODUCTION 7
2) DEFINITION 7
3) LA CONSTRUCTION DU PROTOTYPE D'UN ELEMENT DE LA LISTE 7
4) OPERATIONS SUR LES LISTES DOUBLEMENT CHAINEES 7
A) INITIALISATION 8
B) INSERTION D'UN ELEMENT DANS LA LISTE 8
C) INSERTION AU DEBUT DE LA LISTE 8
D) INSERTION A LA FIN DE LA LISTE 8
E) INSERTION A UNE POSITION QUELCONQUE DE LA LISTE 9
F) SUPPRESSION D'UN ELEMENT DANS LA LISTE 10
G) AFFICHAGE DE LA LISTE 11
H) DESTRUCTION DE LA LISTE 11
III) LES PILES EN LANGAGE C 12
1) INTRODUCTION 12
2) DEFINITION 12
3) LA CONSTRUCTION DU PROTOTYPE D'UN ELEMENT DE LA PILE 12
4) OPERATIONS SUR LES PILES 12
A) INITIALISATION 12
B) INSERTION D'UN ELEMENT DANS LA PILE 13
C) DEPILEMENT DE LA PILE 13
D) LIRE LA VALEUR A L’ENTETE DE LA PILE 13
E) HAUTEUR DE LA PILE : 14
IV) LES FILES EN LANGAGE C 15
1) INTRODUCTION 15
2) DEFINITION 15
3) LA CONSTRUCTION DU PROTOTYPE D'UN ELEMENT DE LA FILE 15
4) OPERATIONS SUR LES FILES 15
A) INITIALISATION 15
B) INSERTION D'UN ELEMENT DANS LA FILE 16
C) DEFILEMENT DE LA FILE 16
D) LIRE LA VALEUR CIBLE (A LA QUEUE) DE LA FILE 16
E) LONGUEUR DE LA FILE : 17

Structures donneenew

Contenu connexe

Tendances

En vedette

Similaire à Structures donneenew

Plus de Rachid Lajouad

Dernier

Structures donneenew