1 #include <stdio.

h>
2 #include <stdlib.h>
3
4 /* run this program using the console pauser or add your own getch, system("pause") or input loop */
5
6 /////////////Exercice 1//////////////////
7
//==============================================================================================================
==================
8 typedef int TypeDonnee;
9
10 typedef struct liste
11 {
12 TypeDonnee donnee;
13 struct liste *suiv;
14 } liste;
15
16 liste *ajoutEnTete(liste *L, TypeDonnee d)
17 {
18 liste *nv=NULL;
19 nv = malloc(sizeof(liste));
20 nv->donnee=d;
21 //if (L==NULL) nv->suiv=NULL;
22 nv->suiv=L;
23 return nv;
24 }
25 void afficheListe(liste *Debut)
26 {
27 liste *p=NULL;
28 p=Debut;
29 while(p!=NULL)
30 {
31 printf("\n %d, %d", p, p->donnee);
32 p= p->suiv;
33 }
34 }
35
36 liste *ajoutEnFin(liste *L, TypeDonnee d)
37 {
38 liste *nv=NULL;
39 nv = malloc(sizeof(liste));
40 nv->donnee=d;
41 nv->suiv = NULL;
42
43 if (L==NULL)
44 L = nv;
45 else
46 {
47 liste *p=NULL;
48 for(p=L; p->suiv!=NULL; p=p->suiv) {}
49
50 p->suiv=nv;
51 }
52 return L;
53
54 }
55
56 void Liberation(liste **Debut)
57 /* passage d’un pointeur par adresse : */
58 /* pointeur sur pointeur */
59 {
60 printf("\nLiberation de memoire\n");
61 liste *p;
62 while (*Debut != NULL) /* tant que la liste est non vide */
63 {
64 p = *Debut; /* mémorisation de l’adresse de la cellule */
 65 *Debut = (*Debut)->suiv; /* cellule suive */
66 free(p); /* destruction de la cellule mémorisée */
67 }
68 *Debut= NULL; /* on réinitialise la liste à vide */
69 }
70
71 liste* detectionAdresse(liste* L, TypeDonnee donnee)
72 {
73 liste* p, *p1;
74 for(p=L; p!=NULL; p=p->suiv)
75 {
76 if(p->donnee==donnee)
77 {
78 p1=p->suiv;//p1 = p;//
79 }//printf(" Adresse des données : %d\n",p);
80 // printf(" Adresse de la donnée : %d\n",p1);
81 // return p1; // Eérreur
82 }
83 return p1;// ok
84 }
85 /*Ajouter en milieu de liste
86 1 allocation de la mémoire pour le nouvel élément
87 2 remplir le champ de données du nouvel élément
88 3 choisir une position dans la liste (l'insertion se fera après la position choisie)
89 4 le pointeur suiv du nouvel élément pointe vers l'adresse sur laquelle pointe le pointeur suiv d'élément
courant
90 5 le pointeur suiv du l'élément courant pointe vers le nouvel élément
91 6 les pointeurs debut et fin ne change pas
92 7 la taille est incrémentée d'une unité*/
93 liste* InsertionAuMilieu(liste* L,TypeDonnee donnee, liste* p)
94 {
95 liste* nv, *p1;
96 nv = (liste*)malloc(sizeof(liste)); //1 allocation de la mémoire pour le nouvel élément
97 nv->donnee=donnee; //2 remplir le champ de données du nouvel élément
98
99 if(L==NULL)
100 L = nv;
101 for(p1 = L; p1->suiv!=p; p1=p1->suiv); //printf("%d",p1);
102 nv->suiv = p1->suiv;
103 //4 le pointeur suiv du nouvel élément pointe vers l'adresse sur laquelle pointe le pointeur suiv
d'élément courant
104 p1->suiv = nv; //5 le pointeur suiv du l'élément courant pointe vers le nouvel élément
105
106 return L;
107 }
108
109
110
111 int Somme(liste * L)
112 {
113 liste *p;
114 int somme = 0;
115 p = L;
116 while (p != NULL)
117 {
118 somme += p->donnee;
119 p = p->suiv;
120 }
121 return somme;
122 }
123 /////////////Exercice 2//////////////////
124
//==============================================================================================================
==================
125
126 liste *Recherche(liste * L, TypeDonnee n)
127 {
128 liste *p, *prec;
129 p = L;
130 while (p != NULL && p->donnee != n)
131 {
132 prec = p;
133 p = p->suiv;
134 }
135
136 if (p == NULL)
137 return NULL;
138 return prec;//adressse précédente de la donnee recherchée n
139 //return p;// adressse de la donnee recherchée n
140 }
141
142 liste *RechercheRec(liste * L, TypeDonnee n)
143 {
144 liste *p = L;
145 if (p == NULL || p->donnee == n)
146 return p;
147 else
148 return RechercheRec(p->suiv, n) ;
149 }
150
151 /* Fonction qui déplace l'élément courant à la position iPosition */
152 /* A la sortie de la fonction le pointeur cour pointera sur l'élément */
153 /* de position iPosition */
154 /* Paramètres d'entrée : */
155 /* liste L : liste où a lieu le déplacement */
156 /* du pointeur cour */
157 /* int iPosition : Position où déplacer cour */
158 /* Paramètre de sortie : rien */
159
160 /////////////Exercice 3//////////////////
161
//==============================================================================================================
==================
162
163 liste *CreerListeduTableau(TypeDonnee * tab, int n)
164 {
165 int i;
166 TypeDonnee donnee;
167
168 liste *nouvelleListe = NULL;
169 for (i = 0; i < n; i++)
170 nouvelleListe = ajoutEnFin(nouvelleListe, tab[i]);// *(tab+i)==tab[i]
171 return nouvelleListe;
172 }
173
174 TypeDonnee *CreerTableaudelaListe(liste * L, int *n)
175 {
176 int i = 0;
177 TypeDonnee *tab;
178 liste *p;
179 p = L;
180 *n = 0; /* compter le nb d’elements a partir de zero */
181 /* compter le nombre d’elements dans la liste */
182 while (p != NULL)
183 {
184 (*n)++;
185 p = p->suiv;
186 }
187 tab = (TypeDonnee *) malloc((*n) * sizeof(TypeDonnee));
188 p = L; /* retourner au debut de la liste */
189 while (p != NULL) /* remplir le tableau */
190 {
191 tab[i] = p->donnee;
192 p = p->suiv;
193 i = i + 1;
194 }
195 return tab;
196 }
197
198 /////////////Exercie 4//////////////////
199
//==============================================================================================================
==================
200 //void afficher(liste*L)
201 liste *CreerListeEnvers(liste * L)
202 {
203 liste *p, *nouveauL = NULL;
204 p = L;
205 while (p != NULL)
206 {
207 nouveauL = ajoutEnTete(nouveauL, p->donnee);//enlever dans la f afficher
208 //printf("adre: %d donnee%d",p,p->donnee);
209 p = p->suiv;
210 }
211 return nouveauL;//enlevier dans la f afficher
212 }
213 /////////////Exercie 5//////////////////
214
//==============================================================================================================
==================
215 liste *RecopieListe(liste * L)
216 {
217 liste *p, *nouveauL = NULL;
218 p = L;
219 while (p != NULL)
220 {
221 nouveauL = ajoutEnFin(nouveauL, p->donnee);
222 p = p->suiv;
223 }
224 return nouveauL;
225 }
226
227
228 /////////////Exercie 6//////////////////
229
//==============================================================================================================
==================
230
231 liste *Supprime1occur(liste * L, TypeDonnee donnee)
232 {
233 liste *courant, *suivant, *pL;
234 courant = L;
235 if (courant == NULL)
236 return L;
237 /*Si la premiere occurrence est le premier element de L*/
238 if (courant->donnee == donnee)
239 {
240 pL = courant->suiv;
241 free(courant);
242
243 }/*Pour les autres cas, on maintient 2 pointeurs: un vers la cellule courante et un vers la cellule
suivante*/
244 suivant = courant->suiv;
245 while (suivant->suiv != NULL && suivant->donnee != donnee)
246 {
247 courant = courant->suiv;
248 suivant = courant->suiv;
249 }//trouver la donnée suivant: adresse de donnee cherchée; courant: adresse precedente
250 if (suivant->donnee == donnee)
251 {
252 courant->suiv = suivant->suiv;
253 free(suivant);
254 }
255 return L;
256 }
257
258 liste *Supprime1occur1(liste * L, TypeDonnee donnee)
259 {
260 liste *courant, *precedent,*p;
261 courant = L;
262 if (courant == NULL)
263 return L;
264
265 /* Si la premiere occurrence est le premier element de L*/
266 if (courant->donnee == donnee)
267 {
268 p = courant->suiv;
269 free(courant);
270 return p;
271 } /*Pour les autres cas, on maintient 2 pointeurs: un vers la cellule courante et un vers la cellule
suivante*/
272
273 precedent = Recherche(L, donnee); //adresse precedente de la donnée recherchée
274 courant = precedent->suiv;
275 printf("\n donnée a suppr%d %d\n", courant, courant->donnee);
276 printf(" adre precedent %d %d\n", precedent, precedent->donnee);
277 precedent->suiv = courant->suiv;
278 free(precedent);
279 return L;
280 }
281
282 liste *Supprimetouteoccur1(liste * L, TypeDonnee donnee)
283 {
284 liste *p;
285 int n=0, i ;
286 p = L;
287 while (p != NULL)
288 {
289 if (p->donnee==donnee)
290 n++; //compte le nombre d'occurence
291 p = p->suiv;
292 }
293 for(i=0 ; i <n ; i++)
294 L = Supprime1occur(L,donnee) ;
295
296 return L ;
297 }
298
299
300
301 liste *Supprimetouteoccur(liste * L, TypeDonnee donnee)
302 {
303 liste *p, *suivant, *pL;
304 p = L;
305 if (p == NULL)
306 return L;
307 while (p->suiv != NULL && p->donnee == donnee)
308 {
309 pL = p;
310 p = p->suiv;
311 free(pL);
312 }
313 if (p->donnee == donnee)
314 {
315 pL = p;
316 L = p->suiv;
317 free(pL);
318 }
319 /*Pour les autres cas, on maintient 2 pointeurs: un vers la cellule courante et un vers la cellule
suivante*/
320 suivant = p->suiv;
321 while (suivant->suiv != NULL)
322 {
323 if (suivant->donnee == donnee)
324 {
325 p->suiv = suivant->suiv;
326 free(suivant);
327 }
328 else
329 p = p->suiv;
330 suivant = p->suiv;
331 }
332 if (suivant->donnee == donnee)
333 {
334 p->suiv = NULL;
335 free(suivant);
336 }
337 return L;
338 }
339
340
341
342 /////////////Exercie 7 //////////////////
343
//==============================================================================================================
==================
344
345 liste *Concatenationdestructrice(liste * L1, liste * L2)
346 {
347 liste *p=NULL;
348 p = L1;
349 while (p->suiv != NULL)
350 {
351 p = p->suiv;
352 }
353 p->suiv = L2;
354 return L1;
355 }
356 liste *Concatenationnondestructrice(liste *L1, liste *L2)
357 {
358 TypeDonnee donnee;
359 liste *p, *L3 = NULL;
360 p = L1;
361 while (p != NULL)
362 {
363 L3 = ajoutEnFin(L3, p->donnee);
364 p = p->suiv;
365 }
366 for(p = L2; p != NULL; p = p->suiv)
367 L3 = ajoutEnFin(L3, p->donnee);
368 // while (p != NULL;) {
369 // L3 = ajoutEnFin(L3, p->donnee);
370 // p = p->suiv;
371 // }
372 return L3;
373 }
374
375
376
377 /////////////Exercie 8 //////////////////
378
//==============================================================================================================
==================
379 /*la fonction retourne 1 si la liste est triee, -1 si elle est vide et 0 si elle n'est pas triee */
380 //a)
381 int VerifieTrie(liste * L)
382 {
383 liste *p, *suivant;
384 if (L == NULL) // liste vide
385 {
386 puts("La liste est vide");
387 return -1;
388 }
389 p = L;
390 suivant = p->suiv;
391 if (suivant == NULL)
392 return 1; /* la liste contient un seul element ==> triée*/
393
394 while (suivant->suiv != NULL && p->donnee < suivant->donnee) //verification
395 {
396 p = p->suiv;
397 suivant = p->suiv;
398 }
399 if (suivant->suiv == NULL) /* on arrive au dernier element */
400 {
401 if (p->donnee < suivant->donnee)
402 return 1; /*la liste est triee */
403 else
404 return 0; /*la liste n'est pas triee */
405 }
406 return 0;
407 }
408
409 // b)
410 liste *InsereElement(liste * L, TypeDonnee donnee)
411 {
412 liste *p, *nouveau, *suivant;
413 nouveau = (liste *) malloc(sizeof(liste));
414 nouveau->donnee = donnee;
415 nouveau->suiv = NULL;
416
417 if (L == NULL)
418 return nouveau;// liste vide
419 p = L;
420 suivant = p->suiv;
421 /*Si la premiere donnee est < que la donnee a inserer */
422 if (p->donnee < donnee)
423 {
424 if (suivant == NULL)
425 {
426 p->suiv = nouveau;
427 return L;
428 }
429 }
430
431 else
432 {
433 nouveau->suiv = p; /* Si la premiere donnee est > a la donnee a inserer */
434 return nouveau;
435 }
436
437 while (suivant->suiv != NULL && suivant->donnee < donnee) // la 2 donnee 3...
438 {
439 p = p->suiv;
440 suivant = p->suiv;
441 }
442 if (suivant->donnee > donnee)
443 {
444 p->suiv = nouveau;
445 nouveau->suiv = suivant;
446 }
447 else
448 suivant->suiv = nouveau;
449 return L;
450 }
451
452 // c)
453
454 void InsereElementTabTriee(TypeDonnee *tab, TypeDonnee donnee, int *nb)
455 {
456 int i = 0, j = 0;
457 while (i < *nb && tab[i] < donnee)
458 i++;
459 /* Augmenter de 1 la taille du tableau alloue */
460 tab = realloc(tab, (*nb + 1) * sizeof(int));
461 if (i == *nb)
462 tab[i] = donnee;
463 else
464 {
465 for (j = (*nb) + 1; j > i; j--)
466 tab[j] = tab[j - 1];
467 /* inserer la donnee a son emplacement i */
468 tab[i] = donnee;
469 }
470 *nb = *nb + 1;
471 }
472
473 // d)
474
475 liste *TriListe(liste * L)
476 {
477 liste *p, *Listetriee = NULL;
478 p = L;
479 while (p != NULL)
480 {
481 Listetriee = InsereElement(Listetriee, p->donnee);
482 p = p->suiv;
483 }
484 return Listetriee;
485 }
486
487
488 /////////////Programme principal//////////////////
489
//==============================================================================================================
==================
490
491 int main(int argc, char *argv[])
492 {
493 printf("\nListe 1\n");
494 liste *L1=NULL,*L2=NULL ;
495 int i;
496 //L1 = ajoutEnFin(L1,20);
497 for (i=0; i<20; i++)
498 {
499 L1= ajoutEnFin(L1,i);
500 L2= ajoutEnFin(L2,i);
501 }
502 int n;
503 // afficheListe(L1);
504 // afficheListe(L2);
505 //
506 // liste *L2=NULL;
507 // L2 = CreerListeEnvers(L1);
508 // printf("\nListe 2\n"); afficheListe(L2);
509 // liste *L3=NULL;
510 // L3 = RecopieListe(L2);
511 // printf("\nListe 3\n"); afficheListe(L3);
512 //
513
514
515
516 // TypeDonnee *tab= CreerTableaudelaListe(L1, &n) ;
517 // for (i=0;i<n;i++) printf("t[i]%d \n", tab[i]);
518 //
519 // liste *L2 = CreerListeduTableau(tab, n) ;
520 //
521 // printf("\nListe 2\n");
522 // afficheListe(L2);
523
524 // printf("\nListe 2\n");
525 // liste *L2 = NULL;
526 // for (i=0;i<10;i++) L2= ajoutEnFin(L2,i);
527 //
528 //
529 // afficheListe(L2);
530 //printf("\n la somme de l1 est %d",Somme(L1));
531 //
532 //printf("\n La recherche d'une donnee dans la liste\n");
533 ////
534 //liste *addr ;
535 //addr= Recherche( L2, 10);
536 //if (addr==NULL) printf("La donnee recherchée n'existe pas");
537 ////
538 //printf("Adressse de 10 est %d", addr);
539 //
540 // Liberation(&L1);
541 //Liberation(&L2);
542 /* //inserer au milieu
543 liste*p = detectionAdresse(L1,3);
544 // printf("donnee recherché : \n%d\n", p->donnee);
545 // printf("adresse de la donnée : \n%d\n",p);
546 //
547 // printf("Apres insertion de 7 au milieu \n\n");
548 L1 = InsertionAuMilieu(L1,20,p);
549 // printf("\nListe 1\n"); afficheListe(L1);
550 //
551 // // Exercice 5
552 //*/
553 // liste *L3 = RecopieListe(L1);
554 /* // printf("\nListe 3 : copie de L1\n"); afficheListe(L3);
555 //
556 // Exercice 6
557 L3 = ajoutEnFin(L3,5);
558 L3 = ajoutEnFin(L3,20);
559 L3 = ajoutEnFin(L3,5);
560 L3 = ajoutEnFin(L3,7);printf("\nListe 3 \n"); afficheListe(L3);
561 L3 = Supprime1occur1(L3, 20);
562 printf("\nListe 3 : suppr de 20 L3\n"); afficheListe(L3);
563
564 L3 = Supprimetouteoccur1( L3, 5);
565 printf("\nListe 3 : supprTous occur de 5 de la liste L3\n"); afficheListe(L3);
566 */
567 //Exercice 7
568 printf("\nListe 1 : \n");
569 afficheListe(L1);
570 printf("\nListe 2 : \n");
571 afficheListe(L2);
572
573 liste *L3 = Concatenationdestructrice(L1,L2);
574 printf("\nListe 3 : construction(L1,L2)\n");
575 afficheListe(L3);
576 //
577 liste *L0 = RecopieListe(L1);
578 liste *L4 = Concatenationdestructrice(L0,L3);
579 printf("\nListe 4 : construction(L0,L3)\n");
580 afficheListe(L4);
581 /*
582 int T[]={1,2,3,4,5,6,7,8};
583 for (i=0;i<8;i++) printf("\naddr %d T[%d]=%d\n",&T[i],i,T[i]);*/
584 return 0;
585 }