Exercices corrigés en Langage C : TP5

Exercices corrigés en Langage C :

Exercice 1 : 

Réécrire la fonction longueur (strln dans string.h) qui calcul la longueur d’une chaîne de caractères.
Prototype : int longueur(char *)

Correction exercice 1 :

int longueur(char *chaine) 
{ 
int i=0 ; 

 while(chaine[i] != ‘\0’) 
i++ ; 
return i ; 
} 

Exercice 2 : 

En utilisant la précédence lexicographique écrire une fonction qui convertie les chaînes de
caractères minuscules en chaînes de caractères majuscules.
Prototype : void majuscule(char *)

Correction exercice 2 :

#include<stdio.h> 
void majuscule(char *) ; 
main() 
{ 
 char chaine[] = "Ceci est une chaine !" ; 
  majuscule(chaine) ; 

 printf("%s\n",chaine) ; 
} 
void majuscule(char *chaine) 
{ 

 int i=0; 

 while(chaine[i] != '\0') 
{ 
if ((chaine[i] >= 'a') && (chaine[i] <= 'z')) 
chaine[i] += (int)'A' - (int)'a' ; 
i++ ; 
} 
} 

Exercice 3 :

Ecrire un programme qui lit deux chaînes de caractères, et qui indique leur précédence
lexicographique dans le code de caractères de la machine (ici: code ASCII). On écrira pour cela la
fonction precedence qui récupère les deux chaînes en paramètre et qui retourne 1 si la première
chaîne précède la deuxième, 2 si la deuxième précède la première, 0 si elle sont égale.
Prototype : int precedence(char *,char *)

Correction exercice 3 :

#include <stdio.h> 
int precedence(char *,char *) ; 
main() 
{ 

 /* Déclarations */ 
char CH1[50], CH2[50]; /* chaînes à comparer */ 
int r ; 

/* Saisie des données */

 printf("Entrez la première chaîne à comparer : "); 
gets(CH1); 
printf("Entrez la deuxième chaîne à comparer : "); 
gets(CH2); 
r = precedence (CH1,CH2) ; 
if(r==0) 
printf("\"%s\" est égal à \"%s\"\n", CH1, CH2); 
else if (r == 1) 
printf("\"%s\" précède \"%s\"\n", CH1, CH2); 
else 
printf("\"%s\" précède \"%s\"\n", CH2, CH1); 
} 
int precedence (char *CH1,char *CH2) 
{ 
int I; /* indice courant */ 
int r ; 

for (I=0; (CH1[I]==CH2[I]) && CH1[I] && CH2[I]; I++) ; 

if (CH1[I]==CH2[I]) 

r = 0 ; 
else if (CH1[I]<CH2[I]) 
r = 1 ; 
else 
r = 2 ; 
return r; 
} 

Exercice 4 : 

Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la
base décimale. On écrira 2 fonctions :
La fonction chaine2entier qui récupère une chaîne de caractère et retourne un entier.
Prototype : int chaine2entier(char *)
La fonction estentier qui récupère un caractère et retourne 0 s’il ne correspond pas à un chiffre 1
s’il correspond à un chiffre.
Prototype : int estentier(char) ;

Correction exercice 4 :

#include<stdio.h> 
int estentier(char) ; 
int chaine2entier(char *) ; 

 main() 
{ 
 /* Déclarations */ 
char CH[100]; /* chaîne numérique à convertir */ 
long N; /* résultat numérique */ 

printf("Entrez un nombre entier et positif : "); 
gets(CH); 
printf("%s\n",CH) ; 

N = chaine2entier(CH) ; 
if(N<0) 
printf("%s ne représente pas correctement un entier positif.\n", CH); 
else 
printf("La chaine %s a pour valeur %d\n" ,CH,N) ; 
} 
 int chaine2entier(char *CH) 
{ 
int I; 
int N = 0 ; 
int OK = 1; 

for (I=0; OK && CH[I]; I++) 
if (estentier(CH[I])) 
N = N*10 + (CH[I]-'0'); 
else 
OK=0; 
if (OK) 
return N ; 
else 
return -1 ; 
} 

int estentier(char c) 
{ 
if ((c>='0')&&(c<='9')) 
return 1 ; 
else 
return 0 ; 
} 

Exercices corrigés en Langage C : TP4

Exercices corrigés en Langage C :

Exercice 1 : 

Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int
(dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entrées au
clavier et afficher le tableau ainsi que la somme de tous ses éléments.
Pour cela on écrira les fonctions suivantes :

void RemplirTableau(void)
void AfficherTableau(void)

Correction exercice 1 :

#include <stdio.h> 
void RemplirTableau(void) ; 
void AfficherTableau(void) ; 

 int T[50][50]; /* tableau donné */ 
int L, C; /* dimensions */ 

main() 
{ 
/* Déclarations */ 
long SOM; /* somme des éléments - type long */ 

/* Saisie des données */ 
printf("Nombre de lignes (max.50) : "); 
scanf("%d", &L ); 
printf("Nombre de colonnes (max.50) : "); 
scanf("%d", &C );

 RemplirTableau() ; 

 AfficherTableau() ; 

 /* Calcul de la somme */ 

for (SOM=0, I=0; I<L; I++) 
for (J=0; J<C; J++) 
SOM += T[I][J]; 

/* Edition du résultat */ 
printf("Somme des éléments : %ld\n", SOM); 
return 0; 
} 

void RemplirTableau(void) 
{ 
int i,j ; 

for (i=0; i<L; i++) 
for (j=0; j<C; j++) 
{ 
 printf("Elément[%d][%d] : ",i,j); 
 scanf("%d", &T[i][j]); 
} 
} 

void AfficherTableau(void) 
{ 
int i,j ; 

printf("Tableau donné :\n"); 
for (i=0; i<L; i++) 
{ 
 for (j=0; j<C; j++) 
printf("%d\t", T[i][j]); 
printf("\n"); 
} 
} 

Exercice 2 : 

Ecrire un programme qui réalise l'addition de deux matrices A et B de même dimension N x M (N
et M sont saisies au clavier).

rappel :

| a | b | + | a’ | b’ | = | a + a’ | b + b’ |
| c | d |   | c’ | d’ |   | c + c‘ | d + d’ |

Correction exercice 2 :

#include <stdio.h> 
main() 
{ 

 /* Déclarations */ 
int A[50][50]; /* matrice donnée */ 
int B[50][50]; /* matrice donnée */ 
int C[50][50]; /* matrice résultat */ 
int N, M; /* dimensions des matrices */ 
int I, J; /* indices courants */ 

/* Saisie des données */ 
printf("Nombre de lignes (max.50) : "); 
scanf("%d", &N ); 

printf("Nombre de colonnes (max.50) : "); 
scanf("%d", &M ); 
printf("*** Matrice A ***\n"); 
for (I=0; I<N; I++) 

for (J=0; J<M; J++) 
{ 
printf("Elément[%d][%d] : ",I,J); 
scanf("%d", &A[I][J]); 
} 
printf("*** Matrice B ***\n"); 
for (I=0; I<N; I++) 
for (J=0; J<M; J++) 
{ 
printf("Elément[%d][%d] : ",I,J); 
scanf("%d", &B[I][J]); 
} 
 /* Affichage des matrices */ 
printf("Matrice donnée A :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", A[I][J]); 
printf("\n"); 
} 
printf("Matrice donnée B :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", B[I][J]); 
printf("\n"); 
} 
 /* Affectation du résultat de l'addition à C */ 
for (I=0; I<N; I++) 
for (J=0; J<M; J++) 
C[I][J] = A[I][J]+B[I][J]; 

/* Edition du résultat */ 
printf("Matrice résultat C :\n"); 
for (I=0; I<N; I++) 
{ 
for (J=0; J<M; J++) 
printf("%7d", C[I][J]); 
printf("\n"); 
} 
return 0; 
} 

Exercice 3 : 

Ecrire un programme qui réalise le produit de deux matrices carrées de même dimension.

rappel :

| a | b | * | a’ | b’ | = | a*a’ + b*c’ | a*b’ + b*d’ |
| c | d |   | c’ | d’ |   | c*a’ + d*c‘ | c*b’ + d*d’ |


Correction exercice 3 :

#include <stdio.h> 
main() 
{ 
 /* Déclarations */ 
int A[50][50]; /* matrice donnée */ 
int B[50][50]; /* matrice donnée */ 
int C[50][50]; /* matrice résultat */ 
int N ; /* dimension des matrices (les matrices sont carrées)*/ 
int i,j,k; /* indices courants */ 

/* Saisie des données */ 
printf("Nombre de lignes et de colonnes (max.50) : "); 
scanf("%d", &N ); 

printf("*** Matrice A ***\n"); 

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


printf("Elément[%d][%d] : ",i,j); 
scanf("%d", &A[i][j]); 

} 
printf("*** Matrice B ***\n"); 
for (i=0; i<N; i++) 


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

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

} 

 /* Affichage des matrices */ 
printf("Matrice donnée A :\n"); 
for (i=0; i<N; i++) 
{ 

for (j=0; j<N; j++) 
printf("%7d", A[i][j]); 

printf("\n"); 
} 
printf("Matrice donnée B :\n"); 
for (i=0; i<N; i++) 
{ 


for (j=0; j<N; j++) 
printf("%7d", B[i][j]); 
printf("\n"); 
} 


 /* Affectation du résultat du produit à C */ 
for (i=0; i<N; i++) 
for (j=0; j<N; j++) 
{ 

C[i][j] = 0 ; 
for(k = 0 ; k<N ; k++) 
C[i][j] += A[i][k]*B[k][j]; 
} 


/* Edition du résultat */ 
printf("Matrice résultat C :\n"); 
for (i=0; i<N; i++) 
{ 

for (j=0; j<N; j++) 
printf("%7d", C[i][j]); 
printf("\n"); 
} 
} 

Exercices corrigés en Langage C : TP3

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 ; 
} 

Exercices corrigés en langage C: TP2

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: TP1

Exercices corrigés en Langage C :

Exercice 1 : 

Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code
numérique en employant getchar et printf,

Correction exercice 1 :

#include <stdio.h> 
main() 
{ 
 int C ; 

printf("introduire un caractère suivi de 'Enter'\n"); 
C = getchar(); 
printf("Le caractère %c a le code ASCII %d\n", C, C); 
return 0; 
} 

Exercice 2 : 

Ecrire un programme qui calcule et affiche la distance DIST (type double) entre deux points A et B
du plan dont les coordonnées (XA, YA) et (XB, YB) sont entrées au clavier comme entiers.

Correction exercice 2 :

#include <stdio.h> 
#include <math.h> 
main() 
{ 


int XA, YA, XB, YB; 
double DIST;


 /* Attention: La chaîne de format que nous utilisons */ 
/* s'attend à ce que les données soient séparées par */ 
/* une virgule lors de l'entrée. */ 

printf("Entrez les coordonnées du point A : XA,YA "); 
scanf("%d,%d", &XA, &YA); 
printf("Entrez les coordonnées du point B : XB,YB "); 
scanf("%d,%d", &XB, &YB); 
DIST=sqrt(pow(XA-XB,2)+pow(YA-YB,2)); 
printf("La distance entre A(%d,% d) et B(%d, %d) est %.2f\n",XA, YA, XB, YB, DIST); 
return 0; 
} 

Exercice 3 : 

Ecrivez un programme qui calcule les solutions réelles d'une équation du second degré
ax2+bx+c = 0 en discutant la formule.

Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et décidez à l'aide de D, si
l'équation a une, deux ou aucune solution réelle. Utilisez des variables du type int pour A, B et C.

Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et

C. Affichez les résultats et les messages nécessaires sur l'écran.
Modifier le programme afin de considérer le cas des solutions complexes.

Correction exercice 3 :

#include <stdio.h> 
#include <math.h> 
main() 

{ 
/* Calcul des solutions réelles et complexes d'une équation du second degré */ 
int A, B, C; 
double D; /* Discriminant */ 

printf("Calcul des solutions réelles et complexes d'une équation du second \n"); 
printf("degré de la forme ax^2 + bx + c = 0 \n\n"); 
printf("Introduisez les valeurs pour a, b, et c : "); 
scanf("%i %i %i", &A, &B, &C);

 /* Calcul du discriminant b^2-4ac */ 
D = pow(B,2) - 4.0*A*C; 

/* Distinction des différents cas */ 
if (A==0 && B==0 && C==0) /* 0x = 0 */ 
printf("Tout réel est une solution de cette équation.\n"); 
else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */ 
printf("Cette équation ne possède pas de solutions.\n"); 
else if (A==0) /* bx + c = 0 */ 
{ 
printf("La solution de cette équation du premier degré est :\n"); 
printf(" x = %.4f\n", (double)C/B); 
} 
else if (D<0) /* b^2-4ac < 0 */ 
{ 
printf("Les solutions complexes de cette équation sont les suivantes :\n"); 
printf(”x1 = %.4f + i%.4f\n”, (double)(-B),(double)(sqrt(-D)/(2*A))) ; 
printf(”x2 = %.4f + i%.4f\n”, (double)(-B),(double)(-sqrt(-D)/(2*A))) ;

 } 
else if (D==0) /* b^2-4ac = 0 */ 
{ 
printf("Cette équation a une seule solution réelle :\n"); 
printf(" x = %.4f\n", (double)-B/(2*A)); 
} 
else /* b^2-4ac > 0 */ 
{ 
printf("Les solutions réelles de cette équation sont :\n"); 
printf(" x1 = %.4f\n", (double)(-B+sqrt(D))/(2*A)); 
printf(" x2 = %.4f\n", (double)(-B-sqrt(D))/(2*A)); 
}
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.

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)
{
 . . .
}