Exercices langage C fonction free

Exercices langage C fonction free

Exercice 1

Ecrire un programme qui lit 10 mots au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Effacer les 10 mots un à un, en suivant l'ordre lexicographique et en libérant leur espace en mémoire. Afficher à chaque fois les mots restants en attendant la confirmation de l'utilisateur (par 'Enter').


Exercice 2

Ecrire un programme qui lit 10 mots au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Copier les mots selon l'ordre lexicographique en une seule 'phrase' dont l'adresse est affectée à un pointeur PHRASE. Réserver l'espace nécessaire à la PHRASE avant de copier les mots. Libérer la mémoire occupée par chaque mot après l'avoir copié. Utiliser les fonctions de <string>.


Exercice 3

Ecrire un programme qui lit 10 phrases au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Réserver dynamiquement l'emplacement en mémoire pour les mots. Trier les phrases lexicographiquement en n'échangeant que les pointeurs. Utiliser la méthode de tri par propagation (méthode de la bulle - décrite dans l'exercice 7.15).


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
 /* Déclarations */
 char INTRO[51];/* chaîne pour l'introduction des données */
 char *MOT[10]; /* Tableau de pointeurs sur les 10 chaînes */
 int MAX;       /* indice du prochain candidat à supprimer */
  int I,J;       /* indices courants */
 /* Saisie des données et allocation dynamique de mémoire */
 puts("Introduire 10 phrases terminées chaque fois"
      " par un retour à la ligne :");
 for (I=0; I<10; I++)
     {
      /* Lecture d'une phrase */
      printf("Phrase %d : ",I);
      gets(INTRO);
      /* Réservation de la mémoire */
      MOT[I] = malloc(strlen(INTRO)+1);
      /* S'il y a assez de mémoire, ... */
      if (MOT[I])
           /* copier la phrase à l'adresse */
           /* fournie par malloc,          */
           strcpy(MOT[I], INTRO);
      else
          {
           /* sinon afficher un message d'erreur */
           printf("\aPas assez de mémoire \n");
           /* et quitter le programme. */
           exit(-1);
          }
      }

 /* Suppression des mots du tableau par ordre lexicographique */
 for (I=0; I<10; I++)
     {
      /* Recherche de la dernière chaîne dans l'ordre   */
      /* lexicographique : Initialiser d'abord MAX avec */
      /* l'indice d'une chaîne encore existante. */
      /* Les conditions de la forme MOT[I] ou !MOT[I]   */
      /* contrôlent si la chaîne I a déjà été supprimée */
      /* ou non. */
      for (MAX=0 ; !MOT[MAX] ; MAX++)
           ;
      for (J=MAX; J<10; J++)
           if (MOT[J] && strcmp(MOT[MAX], MOT[J])>0)
               MAX=J;
      /* Suppression de la chaîne */
      free(MOT[MAX]);
      MOT[MAX]=0;
      /* Affichage des mots restants */
      printf("Passage No.%d :\n", I);
      for (J=0; J<10; J++)
           if (MOT[J]) puts(MOT[J]);
      printf("Poussez Enter pour continuer ...\n");
      getchar();
     }
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
 /* Déclarations */
 char INTRO[51];/* chaîne pour l'introduction des données */
 char *MOT[10]; /* Tableau de pointeurs sur les 10 chaînes */
 char *PHRASE;  /* Pointeur cible */
 int MAX;       /* indice du prochain candidat à copier */
  int I,J;       /* indices courants */
 int L;         /* Longueur de la phrase */

 /* Saisie des données et allocation dynamique de mémoire */
 puts("Introduire 10 phrases terminées chaque fois"
      " par un retour à la ligne :");
 for (I=0; I<10; I++)
     {
      /* Lecture d'une phrase */
      printf("Phrase %d : ",I);
      gets(INTRO);
      /* Réservation de la mémoire */
      MOT[I] = malloc(strlen(INTRO)+1);
      if (MOT[I])
           strcpy(MOT[I], INTRO);
      else
          {
           printf("\aPas assez de mémoire \n");
           exit(-1);
          }
      }
 /* Calcul de la longueur totale de la 'phrase' */
 L=11; /* pour les espaces et le symbole de fin de chaîne */
 for (I=0; I<10; I++)
      L += (strlen(MOT[I])+1);
 /* Réservation de la mémoire pour la 'phrase' */
 PHRASE = malloc(L);
 if (!PHRASE)
     {
      printf("\aPas assez de mémoire pour"
             " mémoriser la phrase.\n");
      exit(-1);
     }
 /* Initialisation de la PHRASE */
 PHRASE[0]='\0';
 /* Copier et supprimer les mots du tableau par */
 /* ordre lexicographique */
 for (I=0; I<10; I++)
     {
      /* Recherche de la dernière chaîne dans l'ordre   */
      /* lexicographique : Initialiser d'abord MAX avec */
      /* l'indice d'une chaîne encore existante. */
      for (MAX=0 ; !MOT[MAX] ; MAX++)   ;
      for (J=MAX; J<10; J++)
           if (MOT[J] && strcmp(MOT[MAX], MOT[J])>0)
               MAX=J;
      /* Copier la chaîne dans la PHRASE */
      strcat(PHRASE,MOT[MAX]);
      strcat(PHRASE," ");
      /* Suppression de la chaîne */
      free(MOT[MAX]);
      MOT[MAX]=0;
     }
  /* Affichage de la PHRASE */
 puts("Résultat :");
 puts(PHRASE);
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
main()
{
 /* Déclarations */
 char INTRO[51]; /* chaîne pour l'introduction des données   */
 char *MOT[10];  /* Tableau de pointeurs sur les 10 chaînes  */
 int I;     /* ligne à partir de laquelle MOT est trié */
  int J;     /* indice courant */
 char *AIDE;/* pour la permutation des pointeurs  */
 int FIN;   /* ligne où la dernière permutation a eu lieu */
     /* permet de ne pas trier un sous-ensemble déjà trié */

 /* Saisie des données et allocation dynamique de mémoire */
 puts("Introduire 10 phrases terminées chaque fois"
      " par un retour à la ligne :");
 for (I=0; I<10; I++)
     {
      /* Lecture d'une phrase */
      printf("Phrase %d : ",I);
      gets(INTRO);
      /* Réservation de la mémoire */
      MOT[I] = malloc(strlen(INTRO)+1);
      if (MOT[I])
           strcpy(MOT[I], INTRO);
      else
          {
           printf("\aPas assez de mémoire \n");
           exit(-1);
          }
      }


 /* Tri du tableau par propagation de l'élément maximal. */
  for (I=9 ; I>0 ; I=FIN)
      {
       FIN=0;
       for (J=0; J<I; J++)
           if (strcmp(MOT[J],MOT[J+1])>0)
             {
              FIN=J;
              AIDE     = MOT[J];
              MOT[J]   = MOT[J+1];
              MOT[J+1] = AIDE;
             }
      }

 /* Affichage du tableau */
 puts("Tableau trié :");
 for (I=0; I<10; I++)
      puts(MOT[I]);
 return 0;
}