Département d’Informatique

Module I133 : Structures de Données en Langage C

Année Universitaire 2021/2022
Parcours MIP (S3)
Pr. B. HSSINA

Corrigé TD No 1
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < string .h >
4 typedef struct {
5 int mois ;
6 int annee ;
7 } Edition ;
8
9 typedef struct {
10 int code ;
11 char titre [30];
12 char specialite [30];
13 char auteur [30];
14 Edition edit ;
15 } Livre ;
16
17 typedef struct element {
18 Livre Liv ;
19 struct element * suivant ;
20 } Liste ;
21 // Cette fonction permet de lire les donn é es d ’ un livre puis le
retourner
22 Livre Lire_livre () {
23 Livre A ;
24 printf ( " Code : " ) ;
25 scanf ( " % d " ,& A . code ) ;
26 printf ( " Titre : " ) ;
27 scanf ( " % s " ,A . titre ) ;
28 printf ( " Specialite : " ) ;
29 scanf ( " % s " ,A . specialite ) ;
30 printf ( " Auteur : " ) ;
31 scanf ( " % s " ,A . auteur ) ;
32 printf ( " Edition ( mois / annee ) : " ) ;
33 scanf ( " % d % d " ,& A . edit . mois ,& A . edit . annee ) ;
34 return A ;
35 }
36 // Cette fonction permet d ’ allouer de l ’ espace m é moire pour un element
de liste
37 Liste * AllouerNoeud ()
38 {
39 Liste * L ;
40 L =( Liste *) malloc ( sizeof ( Liste ) ) ;
41 if ( L == NULL ) { printf ( " Memoire insuffisante \ n " ) ;
42 exit ( -1) ;
43 } else {
44 L - > suivant = NULL ;
45
46 return L ;
47 }
48
49 }

1
50
51 // inserer au d é but de la liste
52 Liste * inserer_debut ( Liste *L , Livre nv )
53 {
54 Liste * q ;
55 q = AllouerNoeud () ;
56 q - > Liv = nv ;
57 if ( L == NULL ) L = q ;
58 else {q - > suivant = L ; L = q ;}
59 return L ;}
60 // Cette fonction permet de retourner le dernier element de la liste
61 Liste * dernier ( Liste * L )
62 {
63 Liste * q = L ;
64 while (q - > suivant != NULL )
65 {
66 q =q - > suivant ;
67 }
68 return q ;
69 }
70 // inserer à la fin de la liste
71 Liste * inserer_fin ( Liste *L , Livre nv )
72 {
73 Liste *q ,* d ;
74 q = AllouerNoeud () ;
75 q - > Liv = nv ;
76 if ( L == NULL ) L = q ;
77 else { d = dernier ( L ) ; d - > suivant = q ;}
78 return L ;
79 }
80
81 void affichage ( Liste * L )
82 {
83 if ( L == NULL ) printf ( " Liste vide .\ n " ) ;
84 else {
85 Liste * q = L ; // pour parcourire la liste en avant
86 printf ( " Affichage de la liste en avant :\ n " ) ;
87
88 while ( q )
89 {
90 printf ( " % d \ t % s \ t % s \ t % s \ t edition % d \ t % d \ n " ,q - > Liv . code ,q - > Liv .
titre ,
91 q - > Liv . specialite ,q - > Liv . auteur ,q - > Liv . edit . mois ,q - > Liv . edit . annee ) ;
92 q =q - > suivant ;}
93
94 }
95 }
96
97 // Suppression des livres dont l ’ auteur = nom_auteur
98 Liste * supprimer ( Liste * L , char * nom_auteur ) {
99 Liste * courant ,* elem_supp ;
100 Liste * Pred ; // Garder l ’ adresse de l ’ element precedent , pendant le
parcours
101 courant = L ;
102
103 while ( courant != NULL )
104 {
105 if ( strcmp ( courant - > Liv . auteur , nom_auteur ) !=0) courant = courant - >

2
 suivant ;
106 else { elem_supp = courant ;
107 if ( courant == L ) { L = courant - > suivant ; courant = L ;}
108 else { Pred - > suivant = courant - > suivant ;
109 courant = courant - > suivant ;
110 }
111
112 free ( elem_supp ) ;
113 }
114 }
115
116 return L ;
117 }
118
119 // comparer 2 edition selon l ’ ann é e et le mois
120 int comparer_edit ( Edition X , Edition Y ) {
121 if ( X . annee < Y . annee ) return -1;
122 else
123 {
124 if ( X . annee > Y . annee ) return 1;
125 else
126 {
127 if ( X . mois < Y . mois ) return -1;
128 else
129 if ( X . mois > Y . mois ) return 1;
130 else return 0 ;
131 }
132 }
133 }
134
135 // parcourir la liste courant1 et courant2
136 Liste * Tri_liste ( Liste * L ) {
137 if ( L != NULL )
138 {
139 Liste * courant1 ,* courant2 ,* min ;
140 Livre aux ;
141
142 for ( courant1 = L ; courant1 - > suivant != NULL ; courant1 = courant1 - > suivant )
143 {
144 min = courant1 ;
145 for ( courant2 = courant1 - > suivant ; courant2 != NULL ; courant2 = courant2 - >
suivant )
146 {
147 if ( comparer_edit ( min - > Liv . edit , courant2 - > Liv . edit ) ==1)
148 min = courant2 ;
149 }
150 if ( min != courant1 )
151 {
152 aux = courant1 - > Liv ;
153 courant1 - > Liv = min - > Liv ;
154 min - > Liv = aux ;
155 }
156 }
157 }
158 return L ;
159 }
160
161 void diviser ( Liste * L , Liste ** L1 , Liste ** L2 ) {

3
162
163 if ( L != NULL )
164 {
165 Liste * courant = L ;
166
167 while ( courant != NULL )
168 {
169
170 if ( strcmp ( courant - > Liv . specialite , " mathematique " ) ==0)
171 {
172 * L1 = inserer_debut (* L1 , courant - > Liv ) ; // ou utiliser inserer_fin ;
173 }
174 if ( strcmp ( courant - > Liv . specialite , " physique " ) ==0)
175 {
176 * L2 = inserer_debut (* L2 , courant - > Liv ) ; // ou utiliser inserer_fin ;
177 }
178
179 courant = courant - > suivant ;
180 }
181 }
182 }
183
184 void enregistrer ( Liste *L , char * nom_fichier )
185 {
186 FILE * F ;
187 F = fopen ( nom_fichier , " w " ) ;
188 Liste * q = L ;
189 while ( q != NULL )
190 {
191 fprintf (F , " % d % s % s % s edition % d % d \ n " ,q - > Liv . code ,q - > Liv . titre ,
192 q - > Liv . specialite ,q - > Liv . auteur ,q - > Liv . edit . mois ,q - > Liv . edit . annee )
;
193 q =q - > suivant ;
194 }
195 fclose ( F ) ;
196 }
197 main ()
198 {
199 Liste * L = NULL ,* L1 = NULL ,* L2 = NULL ;
200 char nom_fichier [30] , nom_auteur [20];
201 Livre A ;
202 int choix ;
203
204
205 do {
206
207 fflush ( stdin ) ; // Vide le tampon clavier avant de poser la question
208 printf ( " Saisir votre choix :\ n " ) ;
209 printf ( " 1 : pour inserer debut .\ n " ) ;
210 printf ( " 2 : pour inserer fin .\ n " ) ;
211 printf ( " 3 : pour Afficher .\ n " ) ;
212 printf ( " 4 : pour supprimer un livre donner .\ n " ) ;
213 printf ( " 5 : pour Diviser en 2 sous listes .\ n " ) ;
214 printf ( " 6 : pour un tri croissant des livres .\ n " ) ;
215 printf ( " 7 : pour Enregistrer la liste dans un fichier texte .\
n");
216 printf ( " 8 : pour arreter .\ n " ) ;
217

4
218 scanf ( " % d " ,& choix ) ;
219 switch ( choix )
220 {
221 case 1 : A = Lire_livre () ; L = inserer_debut (L , A ) ; break ;
222 case 2 : A = Lire_livre () ; L = inserer_fin (L , A ) ; break ;
223 case 3 : affichage ( L ) ; break ;
224 case 4 : printf ( " Donner le nom d auteur du livre a supprimer :\ n " ) ;
225 scanf ( " % s " , nom_auteur ) ; L = supprimer (L , nom_auteur ) ; break ;
226 case 5 : diviser (L ,& L1 ,& L2 ) ;
227 printf ( " liste L1 Mathematique :\ n " ) ; affichage ( L1 ) ;
228 printf ( " liste L2 Physique :\ n " ) ; affichage ( L2 ) ; break ;
229 case 6 : L = Tri_liste ( L ) ; affichage ( L ) ; break ;
230 case 7 : printf ( " Enregistrement dans un fichier .\ n " ) ;
231 printf ( " Donner le nom de fichier : " ) ;
232 scanf ( " % s " , nom_fichier ) ; enregistrer (L , nom_fichier ) ; break ;
233 case 8 : printf ( " Fin programme .\ n " ) ; break ;
234 default : printf ( " Choix invalide \ n " ) ;
235 }
236
237 } while ( choix !=8) ;
238 system ( " pause " ) ;
239 }

5
 Département d’Informatique
Module I133 : Structures de Données en Langage C
Année Universitaire 2019/2020
Parcours MIP (S3)
Pr. B. HSSINA

Corrigé TD No 2
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < math .h >
4 typedef struct {
5 float coef ;
6 int exp ;
7 } Monome ;
8
9 typedef struct element {
10 Monome M;
11 struct element * suivant ;
12 struct element * precedent ;
13 } Poly ;
14
15 // Q1
16 Monome lire_monome ()
17 {
18 Monome A ;
19 printf ( " Donner le coef " ) ; scanf ( " % f " ,& A . coef ) ;
20 printf ( " Donner l exposant " ) ; scanf ( " % d " ,& A . exp ) ;
21 return A ;
22 }
23
24 // Q2
25 Poly * AllouerNoeud ()
26 { Poly * q ;
27 q =( Poly *) malloc ( sizeof ( Poly ) ) ;
28 if ( q == NULL ) { printf ( " Memoire insuffisante \ n " ) ;
29 exit ( -1) ;
30 }
31 else { q - > suivant = NULL ;
32 q - > precedent = NULL ;
33 return q ;
34 }
35 }
36
37 // Q3
38 Poly * s u p p r i m e r _ m o n o m e _ n u l l ( Poly * P )
39 {
40 Poly * elem_supp ;
41 Poly * courant = P ; // parcouririre la liste
42
43 while ( courant != NULL )
44 {
45 if ( courant ->M . coef !=0) { courant = courant -> suivant ;}
46 else { elem_supp = courant ;
47 // suppression au debut
48 if ( courant == P ) { if ( courant -> suivant != NULL )
49 { courant -> suivant -> precedent = NULL ;
50 P = courant -> suivant ; courant = P ;}
51 else { free ( elem_supp ) ; return NULL ;}

6
52 }
53 else if ( courant -> suivant == NULL ) // suppression à la fin
54 { courant -> precedent -> suivant = NULL ; courant = courant
-> precedent ;}
55 // suppression a une position quelconque
56 else { courant -> precedent -> suivant = courant -> suivant
;
57 courant -> suivant -> precedent = courant -> precedent ;
58 courant = courant -> suivant ;
59 }
60 free ( elem_supp ) ;
61 }
62 }
63 return P ;
64 }
65
66 // Q4
67 Poly * ajouterMonome ( Poly * P , Monome m1 ) {
68 Poly * q ;
69 q = AllouerNoeud () ;
70 q - > M = m1 ;
71
72 if ( P == NULL ) return q ;
73 else {
74 if ( m1 . exp > P - > M . exp ) { // insertion au debut du
polynome
75 q - > suivant = P ;P - > precedent = q ;
76 P=q;
77 return P ;
78 }
79 if ( m1 . exp == P - > M . exp ) { // insertion au debut du
polynome avec exp du monome egal expo debut
80 P - > M . coef += m1 . coef ;
81 P = s u p p r i m e r _ m o n o m e _ n u l l ( P ) ; return P ;
82 }
83 else { // insertion ailleurs
84 Poly * courant = P ;
85 while ( courant - > suivant != NULL && courant - > suivant - > M
. exp > m1 . exp )
86 courant = courant - > suivant ;
87
88 if ( courant - > suivant != NULL && courant - > suivant - > M .
exp == m1 . exp )
89 { courant - > suivant - > M . coef += m1 . coef ; P =
s u p p r i m e r _ m o n o m e _ n u l l ( P ) ;}
90 else { if ( courant - > suivant == NULL ) { // insertion fin
91 q - > precedent = courant ; courant - > suivant = q ;}
92 else { // insertion milieu
93 q - > suivant = courant - > suivant ;
94 q - > precedent = courant ;
95 courant - > suivant = q ;
96 courant - > suivant - > precedent = q ;
97 }
98 }
99 return P ;
100 }
101 }
102 }

7
103
104
105 // Q5 == > P (1) =30
106 float evaluer ( Poly * P , float x )
107 {
108 Poly * courant = P ;
109 float S =0;
110 while ( courant )
111 {
112 S +=( courant - > M . coef ) * pow (x , courant - > M . exp ) ;
113 courant = courant - > suivant ;
114 }
115 return S ;
116 }
117
118
119 // Q6 == > affichage polynome
120 void a ff ic ha ge _p ol yn om e ( Poly * P ) {
121 if ( P == NULL ) printf ( " vide .\ n " ) ;
122 Poly * p = P ;
123 while ( p != NULL ) {
124 if (p - > M . exp > 1) {
125 printf ( " %.2 fX ^% d " , p - > M . coef , p - > M . exp ) ;
126 } else {
127 if (p - > M . exp == 1)
128 printf ( " %.2 fX " , p - > M . coef ) ;
129 else
130 printf ( " %.2 f " , p - > M . coef ) ;
131 }
132 p = p - > suivant ;
133 if ( p != NULL ) printf ( " + " ) ;
134
135 }
136 printf ( " \ n " ) ;
137 }
138
139
140 // Q7 == > calculer le d é riv é
141 Poly * deriver_Polynome ( Poly * P ) {
142
143 Poly * courant = P ;
144 Poly * derive = NULL ;
145
146 Monome m ;
147
148 while ( courant != NULL ) {
149
150 m . coef = ( courant - > M . coef ) *( courant - > M . exp ) ;
151 m . exp = courant - > M . exp -1;
152
153 if ( courant - > M . exp != 0 ) derive = ajouterMonome ( derive , m ) ;
154
155 courant = courant - > suivant ;
156
157 }
158 return derive ;
159 }
160

8
161 // Q8 == > d é truire
162 Poly * det ruire_ polyno me ( Poly * P ) {
163 Poly * elem_supp ,* courant = P ;
164 while ( courant != NULL ) {
165 elem_supp = courant ;
166 courant = courant - > suivant ;
167 free ( elem_supp ) ;
168 }
169 return courant ;
170 }
171
172 // Q9
173 main ()
174 {
175 Poly * P1 = NULL ,* D1 = NULL ;
176 float r ;
177 Monome m1 ={15 ,6};
178 Monome m2 ={7 ,4};
179 Monome m3 ={5 ,2};
180 Monome m4 ={3 ,0};
181
182 P1 = ajouterMonome ( P1 , m1 ) ;
183 P1 = ajouterMonome ( P1 , m2 ) ;
184 P1 = ajouterMonome ( P1 , m3 ) ;
185 P1 = ajouterMonome ( P1 , m4 ) ;
186
187
188
189 af fi ch age_ po ly no me ( P1 ) ;
190
191 D1 = deriver_Polynome ( P1 ) ;
192 af fi ch age_ po ly no me ( D1 ) ;
193
194 r = evaluer ( P1 ,1) ;
195 printf ( " P (1) =%.2 f \ n " ,r ) ;
196
197 P1 = de truire _polyn ome ( P1 ) ;
198 af fi ch age_ po ly no me ( P1 ) ;
199
200 system ( " pause " ) ;
201 }

9
 Département d’Informatique
Module I133 : Structures de Données en Langage C
Année Universitaire 2019/2020
Parcours MIP (S3)
Pr. B. HSSINA

Corrigé TD No 3

1 # include < stdio .h >

2 # include < stdlib .h >
3 # include < string .h >
4
5 # define MAX 10
6 typedef struct TPile {
7 char Elts [ MAX ];
8 int NbElts ;
9 } TPile ;
10
11 void initialiser ( TPile * pile ) {
12 pile - > NbElts =0; }
13
14 int pilevide ( TPile pile ) {
15 return pile . NbElts == 0;
16 }
17 int pilepleine ( TPile pile ) {
18 return pile . NbElts == MAX ;
19 }
20 void empiler ( TPile * pile , char obj ) {
21 if ( pilepleine (* pile ) ) {
22 fprintf ( stderr , " Erreur , pile pleine \ n " ) ;
23 }
24 else {
25 pile - > Elts [ pile - > NbElts ] = obj ;
26 pile - > NbElts ++;
27 }
28 }
29 char depiler ( TPile * pile ) {
30 char obj ;
31 if ( pilevide (* pile ) ) {
32 fprintf ( stderr , " Erreur , pile vide \ n " ) ;
33 }
34 else {
35 pile - > NbElts - -;
36 obj = pile - > Elts [ pile - > NbElts ];
37 }
38 return obj ;
39 }
40 void afficher ( TPile pile ) {
41 int i ;
42 if ( pilevide ( pile ) ) printf ( " La pile est vide \ n " ) ;
43 else {
44 if ( pilepleine ( pile ) ) printf ( " La pile est pleine \ n " ) ;
45 printf ( " NbElts = % d \ n " , pile . NbElts ) ;
46 for ( i = pile . NbElts -1; i >=0; i - -) {
47 printf ( " pile [% d ]=% c " , i , pile . Elts [ i ]) ;
48 }
49 printf ( " \ n " ) ;
50 }

10
51 }
52
53 void plindrome ( TPile *P , char * ch )
54 {
55
56 int i =0;
57 int plindrome =1;
58 char x ;
59 while ( ch [ i ]!= ’ \0 ’) { empiler (P , ch [ i ]) ; i ++;}
60 i =0;
61 while (! pilevide (* P ) &&( plindrome ==1) )
62 { x = depiler ( P ) ; if ( x != ch [ i ]) plindrome =0;
63 i ++;
64 }
65
66 if ( plindrome ==1) printf ( " % s est un plindrome \ n " , ch ) ;
67 else printf ( " % s est n est pas un plindrome \ n " , ch ) ;
68 }
69
70 int main () {
71 TPile pile ;
72 char ch [30];
73 initialiser (& pile ) ;
74 printf ( " Donner une chaine : " ) ;
75 gets ( ch ) ;
76 plindrome (& pile , ch ) ;
77 system ( " pause " ) ;
78 }

11
 Département d’Informatique
Module I133 : Structures de Données en Langage C
Année Universitaire 2019/2020
Parcours MIP (S3)
Pr. B. HSSINA

Corrigé TD No 4

Q1 :
1 void initialiser ( TFile * file ) {
2 file - > id = 0;
3 file - > NbElts = 0;
4 }
5 void enfiler ( TFile * file , int obj ) {
6 if ( filepleine (* file ) ) {
7 fprintf ( stderr , " Erreur , file pleine \ n " ) ;
8 }
9 else {
10 int indice ;
11 indice = ( file - > id + file - > NbElts ) % MAX ;
12 file - > Elts [ indice ] = obj ;
13 file - > NbElts ++;
14 }
15 }
16 void defiler ( TFile * file , int * obj ) {
17 if ( filevide (* file ) ) {
18 fprintf ( stderr , " Erreur , file vide \ n " ) ;
19 }
20 else {
21 * obj = file - > Elts [ file - > id ];
22 file - > id ++;
23 if ( file - > id == MAX ) file - > id =0;
24 file - > NbElts - -;
25 }
26 }
27 int filevide ( TFile file ) {
28 return ( file . NbElts == 0) ;
29 }
30 int filepleine ( TFile file ) {
31 return file . NbElts == MAX ;
32 }
33 void afficher ( TFile file ) {
34 int i , indice ;
35 if ( filevide ( file ) ) printf ( " La file est vide \ n " ) ;
36 else {
37 if ( filepleine ( file ) ) printf ( " La file est pleine \ n " ) ;
38 printf ( " id = %d , NbElts = % d \ n " , file . id , file . NbElts ) ;
39 for ( i =0; i < file . NbElts ; i ++) {
40 indice = ( file . id + i ) % MAX ;
41 printf ( " file [% d ]=% d " , i , file . Elts [ indice ]) ;
42 }
43 printf ( " \ n " ) ;
44 }
45 }
Q2 :
1 void trier ( TFile * F1 , TFile * F2 ) {

12
 2 int min , m , t , s ;
3 if ( filevide (* F1 ) ) printf ( " la file est vide \ n " ) ;
4 else
5 while (! filevide (* F1 ) ) {
6 defiler ( F1 ,& min ) ;
7 if (! filevide (* F1 ) ) {
8 t =0; m = F1 - > NbElts ;
9 while (t < m ) {
10 defiler ( F1 ,& s ) ;
11 if ( min >= s ) { enfiler ( F1 , min ) ; min = s ; }
12 else enfiler ( F1 , s ) ;
13 t ++;} }
14 enfiler ( F2 , min ) ;
15 }
16 }
Q3 :
1 int main () {
2 TFile file1 , file2 ;
3 int choix , obj ;
4 initialiser (& file1 ) ;
5 do {
6 printf ( " 1 - Initialiser \ n " ) ;
7 printf ( " 2 - Enfiler \ n " ) ;
8 printf ( " 3 - Defiler \ n " ) ;
9 printf ( " 4 - Afficher \ n " ) ;
10 printf ( " 5 - Trier la file \ n " ) ;
11 printf ( " 0 - quitter \ n " ) ;
12 printf ( " \ tChoix : " ) ;
13 scanf ( " % d " , & choix ) ;
14 switch ( choix ) {
15 case 0: break ;
16 case 1: initialiser (& file1 ) ; break ;
17 case 2: printf ( " \ t \ tvaleur ? " ) ;
18 scanf ( " % d " , & obj ) ;
19 enfiler (& file1 , obj ) ;
20 afficher ( file1 ) ;
21 break ;
22 case 3: defiler (& file1 , & obj ) ;
23 printf ( " \ t \ tvaleur retiree --> % d \ n " , obj ) ;
24 afficher ( file1 ) ;
25 break ;
26 case 4: afficher ( file1 ) ; break ;
27 case 5: initialiser (& file2 ) ;
28 trier (& file1 ,& file2 ) ;
29 printf ( " La file apres le tri \ n " ) ;
30 afficher ( file2 ) ; break ;
31 default : printf ( " erreur ...\ n " ) ; break ;
32 }
33 } while ( choix !=0) ;
34 return 0;
35 }

13