Exercices corrigés en langage C

Exercices corrigés en langage C : Les tableaux en langage C,Les outils de base de la programmation en langage C,Les chaines de caractères en langage C,les fichiers en langage C et les méthodes de tri .

trés bon cours et éxercice en algorithme

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 3 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 4 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

This is default featured post 5 title

Go to Blogger edit html and find these sentences.Now replace these sentences with your own descriptions.

mardi 22 avril 2014

TP3 ; Exercices corrigés en Langage C

Exercices corrigés en Langage C

Exercice 1 :

Ecrire un programme qui saisit la dimension N d’un tableau de int (le tableau est initialement
définit avec une taille maximum MAX que N ne doit pas excéder) remplit le tableau par des valeurs
entrées au clavier et l’affiche.

Le programme doit ensuite effacer toutes les occurrences de la valeur 0 dans le tableau, tasser les
éléments restants et afficher le tableau ainsi modifier.

Pour cela écrire les fonctions suivantes :

void SaisirTableau (int *Tab, int N) ;
void AfficherTableau(int *Tab, int N) ;
int TasserTableau(int *Tab , int N) ;

Correction exercice 1 :

#include <stdio.h> 
#define MAX 50 
void SaisirTableau(int *, int ) ; 
void AfficherTableau(int *, int) ; 
int TasserTableau(int *, int) ; 
main() 
{ 
 /* Déclarations */ 
int T[MAX]; /* tableau donné */ 
int N,M; /* dimension */ 

/* Saisie de la dimension */ 

do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 
}while(N>MAX) ; 

/* Saisie des données */ 

SaisirTableau(T,N) ; 

 /* Affichage du tableau */ 

AfficherTableau(T,N) ; 

/*Tasser les elements du tableau */ 

M = TasserTableau(T,N) ; 

/* Edition des résultats */ 


AfficherTableau(T ,M) ; 

} 

void SaisirTableau(int *Tab, int N) 

{ 
int i ; 

for (i=0; i<N; i++) 

{ 
printf("Elément %d : ", i); 
scanf("%d", &Tab[i]); 
} 
} 

void AfficherTableau(int *Tab, int N) 


{ 

int i ; 
printf("Tableau donné : \n"); 
for (i=0; i<N; i++)

 printf("%d ", Tab[i]); 

printf("\n"); 
} 

int TasserTableau(int * Tab, int N) 

{ 
int i,j ; 

/* Effacer les zéros et comprimer : */ 

/* Copier tous les éléments de i vers j et */ 
/* augmenter j pour les éléments non nuls. */ 

for (i=0, j=0 ; i<N ; i++) 

{ 
Tab[j] = Tab[i] ; 
if (Tab[i]) 
j++ ; 
} 
 /* La nouvelle dimension du tableau est retournée */ 
return j ; 
} 

Exercice 2 :

Ecrire un programme qui saisit la dimension N d’un tableau de int remplit le tableau par des
valeurs entrées au clavier et l’affiche.

Copier ensuite toutes les composantes strictement positives dans un deuxième tableau Tpos et
toutes les valeurs strictement négatives dans un tableau Tneg. Afficher Tpos et Tneg.

Ecrire la fonction suivante :

int TrierTableau(int *, int *, int *,int)

Correction exercice 2 :

#include <stdio.h> 
#define MAX 50 
main() 
{ 
 /* Déclarations */

 /* Les tableaux et leurs dimensions */ 

int T[MAX], TPOS[MAX], TNEG[MAX]; 
int N,M, Npos, NNEG; 
int I; /* indice courant */ 

/* Saisie de la dimension */ 

do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 

}while(N>MAX) ; 


/* Saisie des données */ 


SaisirTableau(T,N) ; 


 /* Affichage du tableau */ 

AfficherTableau(T,N) ; 

/*Tasser les elements du tableau */ 

M = TasserTableau(T,N) ; 

/* Trier le tableau */ 

Npos = TrierTableau(T,TPOS,TNEG,M) ; 

/* Edition des resultats */ 

printf(”Elements positifs : \n”) ; 
AfficherTableau(TPOS,Npos) ; 
printf(”Elements négatifs : \n”) ; 
AfficherTableau(TNEG,N-Npos) ; 

} 

int TrierTableau(int *T, int *TPOS, int *TNEG, int N) 
{ 

 int npos=0, nneg=0; 

int i ; 


 /* Transfert des données */ 


for (i=0; i<N; i++) 

{ 
if (T[i]>0) 
{ 
TPOS[npos]=T[i]; 
npos++; 
} 
if (T[i]<0) 
{ 
TNEG[nneg]=T[i]; 
nneg++; 
} 
} 
return npos ; 
} 

Exercice 3 :

Ecrire un programme qui calcul le produit scalaire de deux vecteurs d’entiers U et V de même
dimension.

Ecrire la fonction suivante :

long ProduitScalaire(int *U,int *V, int dimension)

Correction exercice 3 :

#include <stdio.h> 
#define MAX 50 
long ProduitScalaire(int *,int *, int) ; 
main() 
{ 
 /* Déclarations */ 
int U[MAX], V[MAX]; /* tableaux donnés */ 
int N; /* dimension */ 
int I; /* indice courant */ 
long PS; /* produit scalaire */ 

/* Saisie des données */ 

do 
{ 
printf("Dimension du tableau (max.%d) : ",MAX); 
scanf("%d", &N ); 
}while(N>MAX) ; 
printf("** Premier tableau **\n"); 
for (I=0; I<N; I++) 
{ 
 printf("Elément %d : ", I); 

 scanf("%d", &U[I]); 

} 
printf("** Deuxième tableau **\n"); 
for (I=0; I<N; I++) 
{ 
 printf("Elément %d : ", I); 
 scanf("%d", &V[I]); 
} 

 /* Calcul du produit scalaire */ 


PS = ProduitScalaire(U,V,N) ; 


/* Edition du résultat */ 

printf("Produit scalaire : %ld\n", PS); 
} 

long ProduitScalaire(int *U, int *V,int N) 


{ 

long ps ; 
int i ; 

for (ps=0, i=0; i<N; i++) 

ps += (long)U[i]*V[i]; 
Return ps ; 
} 

TP2 : Exercices corrigés en langage C

Exercices corrigés en Langage C :

Exercice 1 : 

Calculez la somme des N premiers termes de la série harmonique : 1 + 1/2 + 1/3 + ... + 1/N


Correction exercice 1 :

#include <stdio.h> 
main() 
{ 
int N; /* nombre de termes à calculer */ 

int I; /* compteur pour la boucle */ 

float SOM; /* Type float à cause de la précision du résultat. */ 

do 

{ 
printf ("Nombre de termes: "); 
scanf ("%d", &N); 
}while (N<1); 

for (SOM=0.0, I=1 ; I<=N ; I++) 

SOM += (float)1/I; 
printf("La somme des %d premiers termes est %f \n", N, SOM); 
return 0; 
} 

Exercice 2 :

Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier).

Correction exercice 2 :


#include <stdio.h> 
main() 
{ 
int LIG; /* nombre de lignes */ 
int L; /* compteur des lignes */ 
int ESP; /* nombre d'espaces */ 
int I; /* compteur des caractères */ 

do 

{ 
printf("Nombres de lignes : "); 
scanf("%d", &LIG); 
}while (LIG<1 || LIG>20); 
for (L=0 ; L<LIG ; L++) 
{ 
ESP = LIG-L-1; 
for (I=0 ; I<ESP ; I++) 
putchar(' '); 
for (I=0 ; I<2*L+1 ; I++) 
putchar('*'); 
putchar('\n'); 
} 
return 0; 
} 

Exercice 3 :

a) Calculez la racine carrée X d'un nombre réel positif A par approximations successives en
utilisant la relation de récurrence suivante:

XJ+1 = (XJ + A/XJ) / 2 X1 = A

La précision du calcul J est à entrer par l'utilisateur.

b) Assurez-vous lors de l'introduction des données que la valeur pour A est un réel positif et que J
est un entier naturel positif, plus petit que 50.

c) Affichez lors du calcul toutes les approximations calculées :

 La 1ère approximation de la racine carrée de ... est ...
 La 2e approximation de la racine carrée de ... est ...
 La 3e approximation de la racine carrée de ... est ...
 . . .


Correction exercice 3 :
#include <stdio.h> 
main() 
{ 
double A; /* donnée */ 
double X; /* approximation de la racine carrée de A */ 
int N; /* degré/précision de l'approximation */ 
int J; /* degré de l'approximation courante */ 

do 

{ 
printf("Entrer le réel positif A : "); 
scanf("%lf", &A); 

}while(A<0); 

do 
{ 
printf("Entrer le degré de l'approximation : "); 
scanf("%d", &N); 
} 
while(N<=0 || N>=50); 

 for(X=A, J=1 ; J<=N ; J++)


 { 

X = (X + A/X) / 2; 
printf("La %2d%s approximation de la racine carrée" 

" de %.2f est %.2f\n", J, (J==1)?"ère":"e", A, X); 

} 
return 0; 
} 

Exercice 4 :

Affiche la table des produits pour N variant de 1 à 10 :

X*Y I 0  1    2     3    4    5   6   7    8    9     10
0      I 0   0    0    0    0    0    0   0    0    0      0
1      I 0   1    2    3    4    5    6   7    8    9     10
2      I 0   2    4    6    8  10  12  14  16  18    20
3      I 0   3    6    9  12  15  18  21  24  27    30
4      I 0   4    8  12  16  20  24  28  32  36    40
5      I 0   5  10  15  20  25  30  35  40  45    50
6      I 0   6  12  18  24  30  36  42  48  54    60
7      I 0   7  14  21  28  35  42  49  56  63    70
8      I 0   8  16  24  32  40  48  56  64  72    80
9      I 0   9  18  27  36  45  54  63  72  81    90
10    I 0 10  20  30  40  50  60  70  80  90  100


Correction exercice 4 :

#include <stdio.h> 
main() 
{ 
 const int MAX = 10; /* nombre de lignes et de colonnes */ 

 int I; /* compteur des lignes */ 

 int J; /* compteur des colonnes */ 


 /* Affichage de l'en-tête */ 

printf(" X*Y I"); 
for (J=0 ; J<=MAX ; J++)


 printf("%4d", J); 

printf("\n"); 
printf("------"); 
for (J=0 ; J<=MAX ; J++)

 printf("----"); 

printf("\n");

 /* Affichage du tableau */ 

for (I=0 ; I<=MAX ; I++)

 { 

printf("%3d I", I); 
for (J=0 ; J<=MAX ; J++) 


printf("%4d", I*J); 

printf("\n"); 
} 
 return 0; 
} 


Exercices corrigés en langage c : les méthodes de tri

Exercice 1 : Tri de Shell

Traduire la fonction TRI_SHELL définie ci-dessous en C.

Ecrire un programme pour tester la fonction TRI_SHELL.

   procédure TRI_SHELL(T,N)
   |  (* Trie un tableau T d'ordre N par la méthode
   |     de Shell en ordre croissant. *)
   |  résultat: entier tableau T[100]
   |  donnée: entier N
   |  entier SAUT, M, K
   |  booléen TERMINE
   |  en SAUT ranger N
   |  tant que (SAUT>1) faire
   |  |  en SAUT ranger SAUT divent 2
   |  |  répéter
   |  |  |  en TERMINE ranger vrai
   |  |  |  pour M variant de 1 à N-SAUT faire
   |  |  |  |  en K ranger M+SAUT
   |  |  |  |  si (T[M]>T[K]) alors
   |  |  |  |  |   PERMUTER(T[M],T[K])
   |  |  |  |  |   en TERMINE ranger faux
   |  |  |  |  fsi
   |  |  |  fpour
   |  |  jusqu'à TERMINE
   |  ftant (* SAUT <= 1 *)
   fprocédure (* fin TRI_SHELL *)
Remarque: L'algorithme a été développé par D.L.Shell en 1959. En comparant d'abord des éléments très éloignés, l'algorithme a tendance à éliminer rapidement les grandes perturbations dans l'ordre des éléments. La distance entre les éléments qui sont comparés est peu à peu réduite jusqu'à 1. A la fin du tri, les éléments voisins sont arrangés.

Correction exercice 1: Tri de Shell
#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_SHELL(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */

 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_SHELL(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_SHELL(int *T, int N)
{
  /* Trie un tableau T d'ordre N par la méthode de Shell */
 /* Prototypes des fonctions appelées */
 void PERMUTER(int *A, int *B);
 /* Variables locales */
 int SAUT, M, K;
 int TERMINE;
 /* Traitements */
 SAUT = N;
 while (SAUT>1)
     {
      SAUT /= 2;
      do
         {
          TERMINE=1;
          for (M=0; M<N-SAUT; M++)  /* Attention aux indices! */
               {
                K=M+SAUT;
                if (*(T+M) > *(T+K))
                   {
                    PERMUTER(T+M,T+K);
                    TERMINE=0;
                   }
               }
         }
      while(!TERMINE); /* Attention: utiliser la négation de */
     }        /* la condition employée en lang algorithmique */
}

void PERMUTER(int *A, int *B)
{
 int AIDE;
 AIDE = *A;
 *A   = *B;
 *B   = AIDE;
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}
Exercice 2:

Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes:

a) la fonction MAX1 retourne la valeur maximale

b) la fonction MAX2 retourne l'indice de l'élément maximal

c) la fonction MAX3 retourne l'adresse de l'élément maximal

Ecrire un programme pour tester les trois fonctions.


Correction exercice 2:
Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes:
a) la fonction MAX1 retourne la valeur maximale
int MAX1(int *TAB, int N)
{
 int MAX,I;  /* variables d'aide */
 MAX=*TAB;
 for (I=1; I<N; I++)
     if (MAX < *(TAB+I))
         MAX = *(TAB+I);
 return MAX;
}
b) la fonction MAX2 retourne l'indice de l'élément maximal
int MAX2(int *TAB, int N)
{
 int I,MAX; /* variables d'aide */
 MAX=0;
 for (I=1; I<N; I++)
   if (*(TAB+MAX) < *(TAB+I))
         MAX = I;
 return MAX;
}
c) la fonction MAX3 retourne l'adresse de l'élément maximal
int *MAX3(int *TAB, int N)
{
 int *MAX, *P; /* pointeurs d'aide */
 MAX=TAB;
 for (P=TAB; P<TAB+N; P++)
   if (*MAX < *P)
         MAX=P;
 return MAX;
}
Ecrire un programme pour tester les trois fonctions:
#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 int MAX1 (int *TAB, int N);
 int MAX2 (int *TAB, int N);
 int *MAX3(int *TAB, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */

 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 printf("MAX1 : %d \n",   MAX1(T,DIM)  );
 printf("MAX2 : %d \n", T[MAX2(T,DIM)] );
 printf("MAX3 : %d \n",  *MAX3(T,DIM)  );
 return 0;
}

int MAX1(int *TAB, int N)
{
 . . .
}

int MAX2(int *TAB, int N)
{
 . . .
}

int *MAX3(int *TAB, int N)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 3 : Tri par sélection

Ecrire la fonction TRI_SELECTION qui trie un tableau de N entiers par la méthode de sélection directe du maximum (voir exercice 7.14). La fonction fera appel à la fonction PERMUTER (définie dans le cours) et à la fonction MAX3 (définie dans l'exercice précédent).

Ecrire un programme pour tester la fonction TRI_SELECTION.

Correction exercice 3 : Tri par sélection
#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_SELECTION(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */


/* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_SELECTION(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_SELECTION(int *T, int N)
{
  /* Prototypes des fonctions appelées */
 void PERMUTER(int *A, int *B);
 int *MAX3(int *TAB, int N);
 /* Variables locales */
 int I;  /* rang à partir duquel T n'est pas trié */

 /* Tri par sélection directe du maximum */
 for (I=0 ; I<N-1 ; I++)
      PERMUTER(T+I, MAX3(T+I,N-I) );
}

int *MAX3(int *TAB, int N)
{
 . . .
}

void PERMUTER(int *A, int *B)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 4 :

Ecrire la fonction INSERER qui place un élément X à l'intérieur d'un tableau qui contient N éléments triés par ordre croissant, de façon à obtenir un tableau à N+1 éléments triés par ordre croissant. La dimension du tableau est incrémentée dans la fonction INSERER.

Ecrire un programme profitant des fonctions définies plus haut pour tester la fonction INSERER.


Correction exercice 4 : 
#include <stdio.h>
main()
{
 /* Prototypes des fonctions appelées */
 void INSERER(int X, int *T, int *N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 int A;      /* Nombre à insérer */
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 printf("Introduire le nombre à insérer : ");
 scanf("%d", &A);
 INSERER(A, T, &DIM);
  printf("Tableau résultat : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void INSERER(int X, int *T, int *N)
{
  /* Variables locales */
 int I;
 /* Insertion de X dans le tableau T supposé trié: */
 /* Déplacer les éléments plus grands que X d'une  */
 /* position vers l'arrière. */
 for (I=*N ; I>0 && *(T+I-1)>X ; I--)
      *(T+I) = *(T+I-1);
  /* X est copié à la position du dernier élément déplacé */
 *(T+I)=X;
  /* Nouvelle dimension du tableau: */
 (*N)++; /* Attention aux parenthèses ! */
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 5: Tri par insertion

Ecrire la fonction TRI_INSERTION qui utilise la fonction INSERER pour trier par ordre croissant les éléments d'un tableau à N éléments.

Ecrire un programme pour tester la fonction TRI_INSERTION.

Méthode: Trier le tableau de gauche à droite en insérant à chaque fois l'élément I+1 dans le tableau (déjà trié) des I premiers éléments.
algorithme


Correction exercice 5: Tri par insertion
#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void TRI_INSERTION(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_INSERTION(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}


void TRI_INSERTION(int *T, int N)
{
  void INSERER(int X, int *T, int *N);
 /* Variables locales */
 int I;  /* indice courant */
 /* Tri de T par insertion */
 I=1;
 while (I<N)
      INSERER(*(T+I), T, &I);
}

void INSERER(int X, int *T, int *N)
{
 . . .
}

void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}

void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 6 :

Ecrire la fonction RANGER qui arrange le contenu de ses deux paramètres X et Y de façon à ce que le contenu de X soit plus petit que celui de Y. RANGER retourne la valeur logique 1 si un échange a eu lieu, sinon 0.


Correction exercice 6 :
int RANGER(int *X, int *Y)
{
 int AIDE;
 if (*X>*Y)
     {
      AIDE = *X;
      *X = *Y;
      *Y = AIDE;
      return 1;
      }
 else
     return 0;
 }

Exercice 7 : Tri par propagation

Ecrire la fonction TRI_BULLE qui trie un tableau de N éléments entiers par ordre croissant en appliquant la méthode de la bulle (tri par propagation - voir exercice 7.15). Employer la fonction RANGER de l'exercice ci-dessus.

Ecrire un programme pour tester la fonction TRI_BULLE.


Correction exercice 7 : Tri par propagation
#include <stdio.h>
main()
{
 /* Prototypes des fonctions appelées */
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void TRI_BULLE(int *T, int N);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 int T[100]; /* Tableau d'entiers */
 int DIM;    /* Dimension du tableau */
 /* Traitements */
 LIRE_TAB (T, &DIM, 100);
 printf("Tableau donné : \n");
 ECRIRE_TAB (T, DIM);
 TRI_BULLE(T, DIM);
  printf("Tableau trié : \n");
 ECRIRE_TAB (T, DIM);
 return 0;
}

void TRI_BULLE(int *T, int N)
{
  /* Prototypes des fonctions appelées */
 int RANGER(int *X, int *Y);
 /* Variables locales */
 int I,J;  /* indices courants */
 int FIN;  /* position où la dernière permutation a eu lieu */
      /* permet de ne pas trier un sous-ensemble déjà trié. */
 /* Tri de T par propagation de l'élément maximal */
 for (I=N-1 ; I>0 ; I=FIN)
    {
     FIN=0;
     for (J=0; J<I; J++)
          if (RANGER(T+J, T+J+1)) FIN = J;
    }
}

int RANGER(int *X, int *Y)
{
 . . .
}
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}
void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}

Exercice 8 : Fusion de tableaux triés

Ecrire la fonction FUSION qui construit un tableau FUS trié par ordre croissant avec les éléments de deux tableaux A et B triés par ordre croissant. Pour deux tableaux de dimensions N et M, le tableau FUS aura la dimension N+M. (Méthode: voir exercice 7.13)

Ecrire un programme qui teste la fonction FUSION à l'aide de deux tableaux lus au clavier et triés à l'aide de TRI_BULLE.

Correction exercice 8 : Fusion de tableaux triés
#include <stdio.h>

main()
{
 /* Prototypes des fonctions appelées */
 void FUSION(int *A, int *B, int *FUS, int N, int M);
 void TRI_BULLE(int *T, int N);
 void LIRE_TAB (int *TAB, int *N, int NMAX);
 void ECRIRE_TAB (int *TAB, int N);
 /* Variables locales */
 /* Les tableaux et leurs dimensions */
 int A[100], B[100], FUS[200];
 int N, M;
 /* Traitements */
 printf("*** Tableau A ***\n");
 LIRE_TAB (A, &N, 100);
 printf("*** Tableau B ***\n");
 LIRE_TAB (B, &M, 100);
 TRI_BULLE(A, N);
  printf("Tableau A trié : \n");
 ECRIRE_TAB (A, N);
 TRI_BULLE(B, M);
  printf("Tableau B trié : \n");
 ECRIRE_TAB (B, M);
 FUSION(A,B,FUS,N,M);
  printf("Tableau FUS : \n");
 ECRIRE_TAB (FUS, N+M);
 return 0;
}


void FUSION(int *A, int *B, int *FUS, int N, int M)
{
  /* Variables locales */
 /* Indices courants dans A, B et FUS */
 int IA,IB,IFUS; 
 /* Fusion de A et B dans FUS */
 IA=0, IB=0; IFUS=0;
 while ((IA<N) && (IB<M))
    if (*(A+IA)<*(B+IB))
        {
         *(FUS+IFUS)=*(A+IA);
         IFUS++;
         IA++;
        }
    else
        {
         FUS[IFUS]=B[IB];
         IFUS++;
         IB++;
        }
  /* Si A ou B sont arrivés à la fin, alors */
 /* copier le reste de l'autre tableau.    */
 while (IA<N)
     {
      *(FUS+IFUS)=*(A+IA);
      IFUS++;
      IA++;
     }
 while (IB<M)
     {
      *(FUS+IFUS)=*(B+IB);
      IFUS++;
      IB++;
     }
}

void TRI_BULLE(int *T, int N)
{
 /* Prototypes des fonctions appelées */
 int RANGER(int *X, int *Y);
 . . .
}
int RANGER(int *X, int *Y)
{
 . . .
}
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
 . . .
}
void ECRIRE_TAB (int *TAB, int N)
{
 . . .
}


Twitter Delicious Facebook Digg Stumbleupon Favorites More