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 :

allocation de la mémoire pour le nouvel élément 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:

allocation de la mémoire pour le nouvel élément remplir le champ de données du nouvel élément 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:

allocation de la mémoire pour le nouvel élément remplir le champ de données du nouvel élément 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 - %.2f\n", 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.


float Data;

struct ElementListe *precedent;


}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

http://www.commentcamarche.net/faq/sujet-7444-liste-simplement-chainee

http://www.commentcamarche.net/faq/sujet-7444-liste-simplement-chainee


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


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

allocation de la mémoire pour le nouvel élément remplir le champ de données du nouvel élément 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->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: allocation de la mémoire pour le nouvel élément remplir le champ de données du nouvel élément 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) {




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:

allocation de la mémoire pour le nouvel élément remplir le champ de données du nouvel élément 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);



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;


} 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 vide\n");

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 vide\n");

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.


float Data;


}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


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 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) {


*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 vide\n");

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 vide\n");

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

Education

Transcript of Structures donneenew