FAST - Natitingou

Introduction aux structures de données

Projet de programmation en langage C

Objectifs et consignes du projet

L’objectif principal de ce projet est de vous donner l’occasion d’implémenter certaines structures
de données courantes en langage C. Ce projet vise également à améliorer votre niveau général en
C, en vous faisant notamment manipuler des structures de contrôles, des structures de données,
des fonctions, des pointeurs, l’allocation dynamique de mémoire, . . . .
Un soin particulier devra donc être apporté à écrire des programmes spécifiés, documentés et
lisibles. Vous devez aussi systématiquement ajouter en commentaire dans l’entête de chacun de
vos programmes, les noms, prénoms et numéros matricules des membres de votre groupe.

Listes chaînées
Une liste chaînée est une succession ordonnée de cellules qui sont reliées entre elles par des
pointeurs. Une cellule est une “boîte” servant à ranger des valeurs de nature quelconque. Nous
utiliserons pour simplifier des valeurs entières. Quand chaque cellule pointe vers celle qui la
succède, c’est une liste simplement chaînée. Quand une cellule pointe vers celle qui la succède
et qui la précède, c’est une liste doublement chaînée. On convient de considérer que la dernière
cellule a pour successeur NULL, tandis que la première cellule est précédée d’une tête de liste,
notée tete.
Une liste circulaire est alors une liste chaînée dont la tête succède la dernière cellule. C’est à
dire que si la liste est simplement chaînée, la dernière cellule pointe sur la tête et non sur NULL.
On peut également utiliser une liste doublement chaînée pour en faire une liste circulaire. Dans
ce cas, la dernière cellule pointe sur la tête et inversement. On peut également, pour simplifier,
ne pas utiliser de tête dans le cas d’une liste circulaire.
Une liste chaînée ordonnée (ou triée), suivant un ordre sur les valeurs de ses cellules, est une
liste pour laquelle ses cellules sont ordonnées (disons en ordre croissant) sur les valeurs des
différentes cellules de cette liste. Par exemple, si la liste comporte trois cellules A1, A2, A3
ayant respectivement les valeurs 2, 0 et 7, alors l’on doit placer en premier la cellule ayant la
valeur 0 puis celle ayant la valeur 2 et pour finir la cellule ayant la valeur 7. C’est-à-dire qu’on
aura la succession A2, A1 puis A3.
Voici maintenant les structures ainsi que les signatures des méthodes à implémenter pour réaliser
les listes chaînées. Notez-bien que les méthodes sont données seulement pour le cas des listes
simplement chaînées. Vous devez-donc les adapter pour les cas des listes doublement chaînées,
des listes circulaires et des listes chaînées ordonnées.

Listes simplement chaînées

1 // D é claration des structures pour la liste simplement cha î n é e
2 typedef struct Cellule Cellule ;

1
 3 struct Cellule
4 {
5 int valeur ;
6 Cellule * succ ;
7 } ;
8

9 typedef struct LinkedList LinkedList ;

10 struct LinkedList
11 {
12 int numero ; // num é ro de la liste
13 int taille ; // taille de la liste
14 Cellule * tete ; // la t ê te de la liste
15 } ;
16
17 /** D é termine le nombre d ’é l é ments de la liste
18 @pre list != null
19 @post la liste reste inchang é e
20 @return n = | list | , le nombre d ’é l é ment dans la liste
21 */
22 int taille ( LinkedList list ) ;
23
24 /** D é termine si la liste est vide
25 @pre list != null
26 @post list reste inchang é e
27 @result 1 si list == {} , 0 sinon
28 */
29 int estVide ( LinkedList list ) ;
30
31 /** Ajoute la valeur val au d é but de la liste
32 @pre list != NULL
33 @post list devient list + Cellule ( val ) à la premi è re position
34 @result -
35 */
36 void ajouteDebut ( LinkedList * list , int val ) ;
37
38 /** Ajoute la valeur val à la fin de la liste
39 @pre list != NULL
40 @post list devient list + Cellule ( val ) à la derni è re position
41 @result -
42 */
43 void ajouteFin ( LinkedList * list , int val ) ;
44

45 /** Ajoute la valeur val à la position n de la liste

46 @pre list != NULL
47 @post liste devient list + Node ( val ) à la position n de la liste
48 @result -
49 */
50 void ajoutePosition ( LinkedList * list , int val , int position ) ;
51
52 /** Supprime la premi è re Cellule de la liste list
53 @pre list != NULL
54 @post list devient list ’ qui est la list sans son premier é l é ment
55 @result -
56 */
57 void supprimeDebut ( LinkedList * list ) ;
58
59 /** Supprime la derni è re Cellule de la liste list

2
 60 @pre list != NULL
61 @post list devient list ’ qui est la list sans son dernier é l é ment
62 @result -
63 */
64 void supprimeFin ( LinkedList * list ) ;
65

66 /** Supprime la Cellule de la position pos dans la liste list

67 @pre list != NULL
68 @post list devient list ’ qui est la list sans son pos i è me é l é ment
69 @result -
70 */
71 void supprimePosition ( LinkedList * list , int pos ) ;
72
73 /** Donne la premi è re Cellule de la liste list
74 @pre list != NULL
75 @post list reste inchang é e
76 @result donne la premi è re Cellule de la liste
77 */
78 Cellule * donnePremier ( LinkedList * list ) ;
79
80 /** Donne la derni è re Cellule de la liste list
81 @pre list != NULL
82 @post list reste inchang é e
83 @result Donne la premi è re Cellule de la liste .
84 */
85 Cellule * donneDernier ( LinkedList * list ) ;
86
87 /** Donne la Cellule à la position pos de la liste list
88 @pre list != NULL
89 @post list reste inchang é e
90 @result donne la Cellule à la position pos de la liste list
91 */
92 Cellule * donnePosition ( LinkedList * list ) ;
93
94 /** Initialise la liste list en lui attribuant le num é ro number
95 @pre list != NULL
96 @post list est initialis é e et porte le num é ro number
97 @result -
98 */
99 void initList ( LinkedList * list , int number ) ;
100
101 /** Affichage de la liste sous le format
102 Cellule [0] = valeur0
103 Cellule [1] = valeur1
104 ...
105 Cellule [ n ] = valeurn
106 @pre list != NULL
107 @post list reste inchang ée , mais l ’ affichage selon le format sp é cifi é e
108 @result -
109 */
110 void afficheList ( LinkedList list ) ;
111
112 /** Destruction de la liste
113 @pre list != NULL
114 @post la liste est d é truite , y compris toutes ces Cellules
115 @return -
116 */

3
117 void detruitList ( LinkedList * list ) ;

Listes doublement chaînées

1 // D é claration des structures pour la liste doublement cha î n é e
2 typedef struct DCellule DCellule ;
3 struct DCellule
4 {
5 int valeur ;
6 DCellule * next ;
7 DCellule * pred ;
8 } ;
9
10 typedef struct DoubleLinkedList DoubleLinkedList ;
11 struct DoubleLinkedList
12 {
13 int no ; // num é ro de la liste
14 int size ; // taille de la liste
15 DCellule * head ; // la t ê te de la liste
16 } ;

Listes circulaires
1 // D é claration des structures pour les listes circulaires
2 // Liste circulaire simplement cha î n é e
3 typedef struct CircularLList CircularLList ;
4 struct CircularLList
5 {
6 int no ; // num é ro de la liste
7 int size ; // taille de la liste
8 Cellule * head ; // la t ê te de la liste
9 } ;
10
11 // Liste circulaire doublement cha î n é e
12 typedef struct CircularDLList CircularDLList ;
13 struct CircularDLList
14 {
15 int no ; // num é ro de la liste
16 int size ; // taille de la liste
17 DCellule * head ; // la t ê te de la liste
18 } ;

Listes ordonnées
1 // D é claration des structures pour les listes ordonn é es
2 // Liste ordonn é e simplement cha î n é e
3 typedef struct SortLList SortLList ;
4 struct SortLList
5 {
6 int no ; // num é ro de la liste
7 int size ; // taille de la liste

4
 8 Cellule * head ; // la t ê te de la liste
9 } ;
10
11 // Liste ordonn é e doublement cha î n é e
12 typedef struct SortDLList SortDLList ;
13 struct SortDLList
14 {
15 int no ; // num é ro de la liste
16 int size ; // taille de la liste
17 DCellule * head ; // la t ê te de la liste
18 } ;

Piles
Une pile est une succession ordonnée de cellule ayant la caractéristique que la dernière cellule
ajoutée à la pile doit être nécessairement la première à être retirée. On dit qu’une pile est une
structure de type Last In is First Out (LIFO). Il y a seulement deux opérations de base pour
manipuler les piles : empiler - push et depiler - pop. Pour implémenter une pile, on peut
tout aussi bien se servir de listes simplement chaînées, ou de listes doublement chaînées. Dans le
cas de l’utilisation d’une liste simplement chaînée, chaque élément pointe vers son prédécesseur
(par rapport à l’ordre d’ajout des éléments) dans la pile. Le dernier élément (celui se trouvant
complètement en bas, c’est donc le plus ancien élément ajouté et qui s’y trouve toujours) de la
pile pointe alors vers NULL. Par soucis de commodités, on ajoute certaines opérations.
1 // D é claration des structures pour les piles
2 typedef struct Stack Stack ;
3 struct Stack
4 {
5 int no ; // num é ro de la liste
6 int size ; // taille de la liste
7 Cellule * head ; // la t ê te de la liste
8 } ;
9
10 /** D é termine le nombre d ’é l é ments de la Pile
11 @pre pile != null
12 @post la pile reste inchang é e
13 @return n = | pile | , le nombre d ’é l é ment dans la Pile
14 */
15 int taille ( Stack pile ) ;
16
17 /** D é termine si la pile est vide
18 @pre pile != null
19 @post pile reste inchang é e
20 @result 1 si pile == {} , 0 sinon
21 */
22 int estVide ( Stack pile ) ;
23
24 /** Ajoute la valeur val au t ê te de la pile
25 @pre pile != NULL
26 @post pile devient pile + Cellule ( val )
27 @result -
28 */
29 void empiler ( Stack * pile , int val ) ;

5
30
31 /** Enl è ve la valeur val au t ê te de la pile
32 @pre pile != NULL
33 @post pile devient pile ’ qui est la pile sans sa t ê te
34 @result -
35 */
36 void depiler ( Stack * pile ) ;
37
38 /** Initialise la pile en lui attribuant le num é ro number
39 @pre pile != NULL
40 @post pile est initialis é e et porte le num é ro number
41 @result -
42 */
43 void initPile ( Stack * pile , int number ) ;
44
45 /** Affichage de la pile sous le format
46 Cellule [0] = valeur0
47 Cellule [1] = valeur1
48 ...
49 Cellule [ n ] = valeurn
50 @pre pile != NULL
51 @post pile reste inchang ée , mais l ’ affichage selon le format sp é cifi é e
52 @result -
53 */
54 void affichePile ( Stack pile ) ;
55
56 /** Destruction de la pile
57 @pre pile != NULL
58 @post la pile est d é truite , y compris toutes ces Cellules
59 @return -
60 */
61 void detruitPile ( Stack * pile ) ;

File
Une file est également une succession ordonnée de cellules. Sa particularité est que la première
cellule entrée dans la file doit être celle qui sortira en premier de la file. On dit que c’est
une structure de type First In is First Out(FIFO). Tout comme les piles, il y aussi seulement
opérations de base pour manipuler les files : enqueue et dequeue. Enfin l’utilisation d’une liste
simplement chaînée suffit à implémenter une file.
1 // D é claration des structures pour les files
2 typedef struct Queue Queue ;
3 struct Queue
4 {
5 int no ; // num é ro de la liste
6 int size ; // taille de la liste
7 Cellule * head ; // la t ê te de la liste
8 } ;
9
10 /** D é termine le nombre d ’é l é ments de la file
11 @pre file != null
12 @post la file reste inchang é e
13 @return n = | file | , le nombre d ’é l é ment dans la file

6
14 */
15 int taille ( Queue file ) ;
16
17 /** D é termine si la file est vide
18 @pre file != null
19 @post file reste inchang é e
20 @result 1 si file == {} , 0 sinon
21 */
22 int estVide ( Queue file ) ;
23
24 /** Ajoute la valeur val à la queue de la file
25 @pre file != NULL
26 @post file devient file + Cellule ( val )
27 @result -
28 */
29 void enqueue ( Queue * file , int val ) ;
30
31 /** Enl è ve la valeur val à la t ê te de la file
32 @pre file != NULL
33 @post pile devient pile ’ qui est la pile sans sa t ê te
34 @result -
35 */
36 void dequeue ( Queue * file , int val ) ;
37

38 /** Initialise la file en lui attribuant le num é ro number

39 @pre file != NULL
40 @post file est initialis é e et porte le num é ro number
41 @result -
42 */
43 void initQueue ( Queue * file , int number ) ;
44
45 /** Affichage de la file sous le format
46 Cellule [0] = valeur0
47 Cellule [1] = valeur1
48 ...
49 Cellule [ n ] = valeurn
50 @pre file != NULL
51 @post file reste inchang ée , mais l ’ affichage selon le format sp é cifi é e
52 @result -
53 */
54 void afficheFile ( Queue pile ) ;
55

56 /** Destruction de la pile

57 @pre file != NULL
58 @post la file est d é truite , y compris toutes ces Cellules
59 @return -
60 */
61 void detruitFile ( Queue * file ) ;