CHAPITRE 6 : Les tableaux à un seul indice CHAPITRE 6 : Les tableaux à un seul indice

(1)

CHAPITRE 6 : Les tableaux à un seul indice CHAPITRE 6 : Les tableaux à un seul indice

A) Domaines d'utilisation

On utilise souvent les tableaux à un seul indice pour :

 calculer les statistiques de base (moyenne, écart-type, plus grande et plus petite valeur, ...);

 trier, rechercher un élément en particulier ;

 afficher les informations traitées (avant ou après le tri, satisfont aux conditions voulues, etc .).

Très souvent, on lit un fichier de données, on crée les tableaux qui contiennent les informations voulues. Ces tableaux résident alors en mémoire vive (RAM) dont l'accès est beaucoup plus rapide que sur une disquette ou un disque dur. On peut manipuler les informations mémorisées dans ces tableaux. Pour conserver les modifications du contenu de ces tableaux (après les avoir triées ou, après des ajouts, etc.), on recopie ces tableaux dans le fichier original ou dans de nouveaux fichiers.

B) Déclaration

1) Façon directe

Écrire les déclarations directes de 3 tableaux qui contiennent les informations relatives à un groupe de 15 personnes :

age : tableau des entiers représentant les âges des 15 personnes;

taille et poids : deux tableaux de réels.

int age[15];

float taille[25], poids[70];

age est un tableau de 15 entiers. age[0], age[1], ..., age[14] sont 15 éléments du tableau age. Chacun est une variable de type entier.

taille est un tableau de 25 réels. Ses éléments sont taille[0], taille[1], ..., taille[24]. Chacun est une variable de type réel. etc .

La façon de déclarer directement les tableaux est simple.

Chapitre 6 : Les tableaux à un seul indice IFT 1969 / H04 Page 1

(2)

2) Façon structurée

Déclarer les tableaux age, taille, poids, sexe d'un groupe de 150 personnes ou moins.

Style de C :

#define MAX_PERS 150 int age[MAX_PERS];

float taille[MAX_PERS], poids[MAX_PERS];

char sexe[MAX_PERS];

int nbPers; /* le nombre effectif de personnes traitées */

Ce style est simple et on vous le recommande fortement pour le cours IFT 1969.

Style de PASCAL (avec typedef : définition de "nouveau" type) (non demandé dans le cours IFT 1969).

#define MAX_PERS 150

typedef int tabEntier[MAX_PERS];

typedef float tabReel[MAX_PERS];

typedef char tabCar[MAX_PERS];

tabEntier age; /* tableau d'entiers */

tabReel taille, poids; /* tableau des réels */

tabCar sexe; /* tableau des caractères */

Ce deuxième style de déclaration est très lisible et il fonctionne très bien dans n'importe quelle situation (y compris les tableaux à plusieurs indices : au programme du cours IFT 1160).

La déclaration typedef permet de créer des synonymes et de les employer dans d'autres déclarations. Cette technique est utilisée pour clarifier un programme.

typedef int entier; /* entier est synonyme à int */

typedef int boolean; /* boolean est synonyme à int */

Avec :

typedef int tabEntier[MAX_PERS];

tabEntier est le nom du type tableau de 150 entiers.

(3)

C) Schéma d'un tableau

On représente (imagine) un tableau comme une commode à plusieurs tiroirs dont chaque tiroir contient un seul objet de même type, comme par exemple, dans le cas de la déclaration d'un tableau age de 15 éléments de type entier

int age[15];

age[0] 45

age[1] 20

age[2] 27

age[3] 49

... ...

age[14] 21

D) Manipulations d'un tableau

1) On crée souvent des tableaux en lisant un ou plusieurs fichiers de données. Dans ce cas, on utilise fréquemment la boucle while :

...

donnees = fopen("taille.dta", "r");

int n = 0; /* compteur */

while (!feof(donnees)){

fscanf(donnees,"%f\n", &taille[n]);

n++;

}

fclose(donnees);

2) On parcours les indices d'un tableau avec la boucle for. Notez que le premier indice est zéro :

for (i = 0; i < nbElement; i++) ...

3) Pour le cours IFT 1969 on manipule un tableau en utilisant des indices.

Les autres méthodes de manipulation (avec pointeur) seront présentées dans le cours suivant : IFT 1160.

(4)

E) Exemples et exercices

Exemple 1 : création des tableaux et calculs des statistiques

On dispose d’un fichier texte "mesures.dta". Chaque ligne de ce fichier contient les informations d'une seule personne : sa taille et son poids.

1.63 54.9 1.57 56.3 1.73 63.0 etc.

Écrire un programme utilisant des tableaux pour calculer et afficher les statistiques suivantes :

 la taille la plus grande;

 le poids moyen.

Solution

#include <stdio.h>

void main() {

#define MAX_PERS 20 /* 20 personnes ou moins dans le fichier */

float taille[MAX_PERS], poids[MAX_PERS],

taillePG, /* taille la plus grande */

somPoids;

int nbPers, i;

FILE *aLire = fopen("mesures.dta", "r");

/* Création des 2 tableaux et compter le nb. effectif de personnes */

nbPers = 0; /* compteur du nombre de personnes lues */

while (!feof(aLire)){

fscanf(aLire, "%f%f\n", &taille[nbPers], &poids[nbPers]);

nbPers++;

}

fclose(aLire);

if (nbPers > 0){

/* Calcul des statistiques : */

taillePG = 0.0; /* valeur suffisamment petite */

somPoids = 0.00;

for (i = 0; i < nbPers; i++){

if (taille[i] > taillePG) taillePG = taille[i];

somPoids += poids[i];

}

printf("La taille la plus grande : %5.2 mètre\n", taillePG);

printf("Le poids moyen : %6.2f kgs\n", somPoids / nbPers);

(5)

} }

(6)

Exemple 2 : tri d'un tableau

Le but d'un tri est de mettre en ordre les valeurs des éléments d'un tableau.

Dans le cours IFT 1969, on présente une seule méthode de tri : le tri par sélection. Deux autres méthodes plus rapides (le tri rapide "Quick Sort" et le tri par arbre binaire) seront présentées dans le deuxième cours de programmation IFT 1160 (La programmation avec le langage C).

Tri par sélection

Pour comprendre cette méthode, on observe un tableau T qui contient 5 entiers (nbElement vaut 5 ) :

Avant tri

L'indice i = 0

Quelle sera la valeur à placer à l'indice 0? C'est manifestement la valeur 17 située à l'indice 3 dans le tableau. Pour nous, c'est évident.

Mais comment procéder pour que l'ordinateur puisse trouver l'indice 3 qui est l'indice contenant la valeur minimale (indMin)?

On initialise cet indice à i :

indMin = i; /* qui vaut zéro */

On compare t[indMin] avec t[1], t[2], ..., t[4]. Quand on découvre une valeur qui est encore petite, on ajuste la valeur de indMin :

Pour j allant de 1 à 4 Faire

Si t[j] < t[indMin] Alors indMin = j

j vaut 1: t[1] < t[0]? <==> 25 < 50? Oui ==> indMin = 1

j vaut 2: t[2] < t[1]? <==> 34 < 25? Non ==> on ne modifie pas indMin j vaut 3: t[3] < t[1]? <==> 17 < 25? Oui ==> indMin = 3

j vaut 4: t[4] < t[3]? <==> 48 < 17? Non ==> on ne modifie pas indMin

Après avoir comparé avec les autres valeurs dans le tableau, on a 3 comme valeur dans indMin. Est-ce que 3 est le même indice que i qui vaut actuellement

T(0) T(1) T(2) T(3) T(4)

50 25 34 17 48

i

j = 1,2

indMin

j = 3,4

(7)

0? Non. Donc, on a trouvé une plus petite valeur que celle qui est à la position 0 dans le tableau, on échange (permute) t[0] et t[3] :

L'indice i = 1 :

Quelle sera la valeur à placer à l'indice 1? C'est bien évidemment 25 et cette valeur est déjà à la bonne position dans le tableau, soit à l'indice 1.

Comment faire en sorte que l'ordinateur puisse trouver l'indice 1 qui est l'indice contenant la valeur minimale (indMin) à partir de i = 1?

On initialise cet indice à i :

indMin = i; /* qui vaut actuellement 1 */

On compare t[indMin] avec t[2], t[3], ..., t[4]. Quand on découvre une valeur qui est encore petite, on ajuste la valeur de indMin :

Pour j allant de 2 à 4 Faire

Si t[j] < t[indMin] Alors indMin = j j vaut 2: t[2] < t[1]? <==> 34 < 25? ==> Non j vaut 3: t[3] < t[1]? <==> 50 < 25? ==> Non j vaut 4: t[4] < t[1]? <==> 48 < 25? ==> Non

Après avoir comparé avec les autres éléments du tableau, indMin vaut 1. Est-il le même indice que i (qui vaut 1)? Oui. Donc, on n'a pas besoin de permuter.

On a :

A titre d'exercice, faire la même simulation pour i = 2 et i = 3 Après avoir fait la simulation avec i = 2 et i = 3, on a donc :

T(0) T(1) T(2) T(3) T(4)

17 25 34 50 48

T(0) T(1) T(2) T(3) T(4)

17 25 34 50 48

T(0) T(1) T(2) T(3) T(4)

17 25 34 48 50

i

j = 2, 3, 4

indMin

(8)

On n'a pas besoin de le faire pour i = 4. En effet, pour un tableau de 5 éléments, si les 4 premiers sont déjà en ordre, le cinquième (t[4] en langage C) sera nécessairement le plus grand.

Algorithme pour trier un tableau T :

/* Du premier à l’avant-dernier élément Faire : */

Pour i allant de 0 à Nb_Element - 2 Faire Début

indMin <---- i

/* Comparer avec le reste pour ajuster indMin */

Pour j allant de i + 1 à nbElement - 1 Faire Si t[j] < t[indMin] Alors

indMin <---j

/* Permuter, si nécessaire, t[i] et t[indMin] */

Si indMin est différent de i Alors Permuter t[i] et t[indMin]

Fin

Permutation du contenu de deux variables :

Soient deux variables de même type a et b (ici de type "int"); a vaut 15 et b vaut 5 :

int a = 15, b = 5;

Permuter A et B signifie changer le contenu de ces deux variables de la façon suivante : a vaudra 5 et b vaudra 15 après une bonne permutation.

Analysons l'exécution des deux instructions suivantes :

a = b;

b = a;

L'instruction "a = b;" signifie qu'on dépose la valeur de b dans a. A vaut donc maintenant 5.

Puis, avec l'instruction "b = a;" on dépose a dans b, a devient donc la nouvelle valeur de b; b vaut donc maintenant 5.

Ainsi, a vaut 5 et b vaut 5. Ceci n'est pas du tout une permutation.

Pour permuter un verre de vin et un verre d'eau, on ne verse jamais l'eau dans le vin (b = a;). On utilise plutôt un troisième verre (un verre temporaire) :

À l'étape 1, on verse l'eau dans le verre temporaire (temp).

(9)

Eau Vin

a temp b

À l'étape 2, on verse le vin dans le verre d'eau.

Eau Vin

a temp b

À l'étape 3, on verse le verre temporaire dans le verre de vin.

Vin Eau Eau

a temp b

Pour permuter a (vaut 15) et b (vaut 5) :

int a = 15, b = 5, temp;

temp = b;

b = a;

a = temp;

On utilise ainsi une variable temporaire et trois affectations pour permuter le contenu de deux variables de même type.

Exemple 1 du tri par sélection

On dispose du fichier de type texte du nom "tailles.dta". Chaque ligne du fichier contient la taille d'une personne :

1.65 1.57 1.92 etc.

On a moins de 20 personnes dans le fichier. Écrire un programme qui permet :

 de lire le fichier et de créer le tableau des tailles des personnes;

 afficher la liste des tailles avant le tri;

 trier les tailles;

 afficher la liste des tailles après le tri.

(10)

Solution

#include <stdio.h>

void main() {

FILE *aLire;

#define MAX_PERS 20 float taille[MAX_PERS];

int nbPers, i, j, indMin;

float tempo;

printf("La creation du tableau des tailles\n");

aLire = fopen("tailles.dta", "r");

nbPers = 0;

fscanf(aLire, "%f\n", &taille[nbPers]);

nbPers++;

}

fclose(aLire);

printf("\nLe contenu du tableau des tailles avant le tri:\n");

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

printf("%5d) %7.2f\n", i + 1, taille[i]);

printf("\n\nAppuyez sur Entree pour demarrer le tri ");

getchar();

for (i = 0; i < nbPers - 1; i++){

indMin = i;

for (j = i + 1; j < nbPers; j++) if (taille[j] < taille[indMin]) indMin = j;

if (indMin != i){

tempo = taille[i];

taille[i] = taille[indMin];

taille[indMin] = tempo;

} }

printf("\n\nAppuyez sur Entree pour la liste apres le tri ");

getchar();

printf("\nLe contenu du tableau des tailles apres le tri:\n");

printf("%5d) %7.2f\n", i+1, taille[i]);

printf("\n\nAppuyez sur Entree pour quitter ");

getchar();

(11)

}

(12)

Exécution

La creation du tableau des tailles

Le contenu du tableau des tailles avant le tri:

1) 1.65 2) 1.57 3) 1.92 4) 1.72 5) 1.85 6) 1.68 7) 1.25 8) 1.93 9) 2.04 10) 1.72 11) 1.64 12) 1.72 13) 1.85 14) 1.58

Appuyez sur Entree pour demarrer le tri

Appuyez sur Entree pour la liste apres le tri Le contenu du tableau des tailles apres le tri:

1) 1.25 2) 1.57 3) 1.58 4) 1.64 5) 1.65 6) 1.68 7) 1.72 8) 1.72 9) 1.72 10) 1.85 11) 1.85 12) 1.92 13) 1.93 14) 2.04

Mise en garde : cas de plusieurs tableaux

Imaginez le cas simple suivant : on a trois tableaux : sexe, numero et poids de 2 personnes seulement :

sexe[0] 'F' numero[0] 1350 poids[0] 58.5

sexe[1] 'M' numero[1] 975 poids[1] 75.8

Supposons qu'on veuille trier ces trois tableaux selon les numéros.

(13)

Pour l'indice i = 0, on a indMin = 0 (initialisation). On compare avec le reste (ici, seulement avec numero[1]) :

numero[1] < numero[indMin]? <==> 975 < 1350? <==> Oui ==> indMin = 1

Comme 1 est différent de 0 on permute les numéros :

Ainsi, la personne numéro 975 qui était un homme qui pesait 75.8 kg devient une femme qui pèse 58.5 kg. On devient des chirurgiens au lieu d'être programmeurs!

Conclusion

Lors d'un échange pendant le tri, il faut échanger aussi les éléments correspondants dans les autres tableaux pour ne pas mélanger les informations :

Exemple 2 du tri par sélection

On dispose du fichier de type texte du nom "metrique.txt". Chaque ligne du fichier contient les informations suivantes relatives à une seule personne : un caractère représentant son sexe, son numéro, sa taille et son poids :

F 1005 1.47 45.81 F 1406 1.52 44.91 M 1405 1.55 55.34 etc.

On a moins de 10 personnes dans le fichier. Écrire un programme qui permet de :

 lire le fichier et de créer les 4 tableaux : sexe, numero, taille, poids;

 afficher la liste des informations avant le tri;

 trier selon les numéros;

 afficher la liste des informations après le tri;

(14)

 créer un fichier de type texte du nom "mesures.fem" qui ne contient que le

numéro, la taille et le poids de chacune des femmes.

(15)

Solution

#include <stdio.h>

void main() {

FILE *aLire, *aCreer;

#define MAX_PERS 10

float taille[MAX_PERS], poids[MAX_PERS];

char sexe[MAX_PERS];

int numero[MAX_PERS];

int nbPers, i, j, indMin;

/* pour les permutations */

float tempo;

int tempo2;

char tempo3;

printf("La creation des tableaux\n");

aLire = fopen("metrique.txt", "r");

nbPers = 0;

fscanf(aLire, "%c%d%f%f\n", &sexe[nbPers], &numero[nbPers], &taille[nbPers], &poids[nbPers]);

nbPers++;

}

fclose(aLire);

printf("\nLe contenu des 4 tableaux avant le tri:\n");

printf("%5d) %3c %6d %7.2f %7.2f\n", i + 1, sexe[i], numero[i], taille[i], poids[i]);

printf("\nAppuyez sur Entree pour demarrer le tri ");

getchar();

for (i = 0; i < nbPers - 1; i++){

indMin = i;

for (j = i + 1; j < nbPers; j++) if (numero[j] < numero[indMin]) indMin = j;

if (indMin != i){

tempo = taille[i];

taille[i] = taille[indMin];

taille[indMin] = tempo;

(16)

tempo = poids[i];

poids[i] = poids[indMin];

poids[indMin] = tempo;

tempo2 = numero[i];

numero[i] = numero[indMin];

numero[indMin] = tempo2;

tempo3 = sexe[i];

sexe[i] = sexe[indMin];

sexe[indMin] = tempo3;

} }

printf("\n\nAppuyez sur Entree pour la liste apres le tri ");

getchar();

printf("\nLe contenu des 4 tableaux apres le tri:\n");

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

printf("%5d) %3c %6d %7.2f %7.2f\n", i + 1, sexe[i], numero[i], taille[i], poids[i]);

printf("\nCreation du fichier mesures.fem\n");

aCreer = fopen("mesures.fem", "w");

for (i = 0; i < nbPers; i++) if (sexe[i] == 'F')

fprintf(aCreer,"%5d %7.2f %7.2f\n", numero[i], taille[i], poids[i]);

fclose(aCreer);

printf("\nAppuyez sur Entree pour quitter ");

getchar();

}

Exécution

La creation des tableaux

Le contenu des 4 tableaux avant le tri:

1) F 1005 1.47 45.81 2) F 1406 1.52 44.91 3) M 1405 1.55 55.34 4) F 1504 1.57 50.80 5) M 1407 1.57 51.71 6) M 1901 1.57 56.25 7) M 1807 1.63 60.33

Appuyez sur Entree pour demarrer le tri

Appuyez sur Entree pour la liste apres le tri Le contenu des 4 tableaux apres le tri:

1) F 1005 1.47 45.81 2) M 1405 1.55 55.34 3) F 1406 1.52 44.91 4) M 1407 1.57 51.71 5) F 1504 1.57 50.80 6) M 1807 1.63 60.33 7) M 1901 1.57 56.25

(17)

Creation du fichier mesures.fem Appuyez sur Entree pour quitter Le contenu du fichier mesures.fem:

1005 1.47 45.81 1406 1.52 44.91 1504 1.57 50.80

Exemple 3 : un peu de calcul et d'algorithmie Les diviseurs de 6 sont 1, 2, 3, 6.

Les diviseurs "propres de 6" sont 1, 2 et 3 (le 6 est exclu).

On a 1 + 2 + 3 = 6.

6 est égal à la somme de ses diviseurs propres. On dit que 6 est un nombre

"parfait".

Entre 2 et 500, à part le 6, on a au total 3 nombres parfaits. Écrire un programme qui permet de découvrir ces trois nombres, de mémoriser ses diviseurs dans un tableau et d'afficher les 3 lignes du genre suivant :

1. 6 = 1 + 2 + 3 2. etc.

Solution

#include <stdio.h>

void main() {

const int BORNE1 = 2, BORNE2 = 500;

int nombre, somDivProp, k, nbDiv, i,

nbParfait = 0; /* compteur des nombres parfaits */

/* le tableau des diviseurs de chacun des nombres parfaits */

#define MAX_DIV 50 int divi[MAX_DIV];

printf("Voici les nombres parfaits entre %d et %d:\n\n", BORNE1, BORNE2);

for (nombre = BORNE1; nombre <= BORNE2; nombre++ ){

/* On vérifie si le nombre est parfait : */

somDivProp = 0;

for (k = 1; k <= nombre / 2; k++ ) if (nombre % k == 0)

somDivProp += k;

if (somDivProp == nombre){

/* C'est un nombre parfait : */

nbParfait++; /* un nombre parfait de plus */

(18)

printf("%5d) %5d = ", nbParfait, nombre);

/* Mémoriser dans le tableau ses diviseurs propres */

nbDiv = 0;

for (k = 1; k <= nombre / 2; k++) if (nombre % k == 0){

divi[nbDiv] = k;

nbDiv++;

}

/* afficher avec la disposition requise */

for (i = 0; i < nbDiv - 1; i++) printf("%3d + ", divi[i]);

printf("%3d\n\n", divi[nbDiv-1]);

} }

printf("Appuyez sur Entree ");

getchar();

}

Exécution

Voici les nombres parfaits entre 2 et 500:

1) 6 = 1 + 2 + 3

2) 28 = 1 + 2 + 4 + 7 + 14

3) 496 = 1 + 2 + 4 + 8 + 16 + 31 + 62 + 124 + 248

N.B. : plusieurs autres exemples seront présentés lorsque nous travaillerons avec des fonctions.

Autres exemples Exemple 1

/* Fichier tableau1.c (tableau, stats, for, fichier, ....) Déclarer deux tableaux :

tableau des tailles des 10 personnes (tableau des réels) tableau des caractères représentant le sexe des personnes Initialiser seulement les valeurs des 7 premières personnes Compter et afficher

- le nombre d'hommes traités

- le nombre de femmes mesurant plus de 1.68 mètre Calculer et afficher : la taille moyenne des hommes Déterminer et afficher :

- la taille la plus grande

(19)

- la taille la plus petite

Créer un fichier qui ne contient que des femmes */

#include <stdio.h>

void main() {

const double BORNE = 1.68; /* combien de femmes mesurent plus que cette valeur ? */

#define MAX_PERS 10 /* au maximum : 10 personnes à traiter */

#define NOM_FICHIER "femmes.dta" /* nom externe du fichier */

double taille[MAX_PERS] = {1.72, 1.68, 1.80, 1.60, 1.70, 1.65, 1.75};

char sexe[MAX_PERS] = {'F', 'M', 'F', 'F', 'M', 'F', 'F'};

int nbPers = 7; /* on a 7 personnes à traiter */

int nbHom = 0, /* compteur du nombre d'hommes */

nbFemPGBorne = 0,

i; /* variable de contrôle de la boucle for */

double somTailHom = 0.0, /* la somme des tailles des hommes */

pgTaille, /* la taille la plus grande */

ppTaille; /* la taille la plus petite */

/* déclarer et initialiser le fichier à créer */

FILE *aCreer = fopen(NOM_FICHIER, "w");

/* initialiser la taille plus grande et la taille plus petite */

pgTaille = 0.0 ; /* valeur SUFFISAMMENT petite */

ppTaille = 100.0; /* valeur SUFFISAMMENT grande */

/* examiner personne par personne */

for (i = 0; i < nbPers; i++){

printf("%3d) %c %6.2f metre\n", i + 1, sexe[i], taille[i]);

if (sexe[i] == 'M'){ /* cas d'un homme */

nbHom++;

somTailHom += taille[i];

}else{ /* cas d'une femme */

if (taille[i] > BORNE) nbFemPGBorne++;

/* écrire dans le fichier le sexe et la taille */

fprintf(aCreer,"%c %6.2f\n", sexe[i], taille[i]);

}

/* ajuster la taille la plus grande et la plus petite */

if (taille[i] > pgTaille) pgTaille = taille[i];

(20)

if (taille[i] < ppTaille) ppTaille = taille[i];

}

/* obligatoire : fermer le fichier */

fclose(aCreer);

printf("\n\nLe nombre d'hommes traites : %d\n", nbHom);

printf("Le nombre de femmes mesurant plus de %6.2f metre est %d\n", BORNE, nbFemPGBorne);

if (nbHom > 0)

printf("La taille moyenne des hommes : %6.2f metre\n",

somTailHom / nbHom);

printf("\nLa taille la plus grande : %6.2f metre\n", pgTaille);

printf("La taille la plus petite : %6.2f metre\n", ppTaille);

printf("Le fichier %s vient d'etre cree\n\n", NOM_FICHIER);

}

Exécution

1) F 1.72 metre 2) M 1.68 metre 3) F 1.80 metre 4) F 1.60 metre 5) M 1.70 metre 6) F 1.65 metre 7) F 1.75 metre

Le nombre d'hommes traites : 2

Le nombre de femmes mesurant plus de 1.68 metre est 3 La taille moyenne des hommes : 1.69 metre

La taille la plus grande : 1.80 metre La taille la plus petite : 1.60 metre Le fichier femmes.dta vient d'etre cree

Contenu du fichier femmes.dta cree : F 1.72

F 1.80 F 1.60 F 1.65 F 1.75