Td corrigé Chapitre 3 : Tableaux pdf

Chapitre 3 : Tableaux

MODULE : TP D'ALGORITHMIQUE SUR LES PROBABILITES. Exercice 1 : lancer d'un dé à 6 faces. Partie A. On s'intéresse au lancer d'un dé équilibré à 6 ...




part of the document



e, taille, poids, sexe d'un groupe
de 150 personnes ou moins.

1. 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 */
2. Style en PASCAL (avec typedef : définition de type)

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 char * Chaine ; /* Chaine est synonyme à char* */

Avec : typedef int TabEntier[MAX_PERS] ;
TabEntier est le nom du type tableau de 150 entiers.

Les déclarations des tableaux peuvent se faire comme suit :

#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 */

3. Style de C++ (utilisation de const à la place de #define)
(Ce n'est plus une matière du IFT 1160)

const int MAX_PERS = 150;

float taille[MAX_PERS], poids[MAX_PERS]; /* non valide en */
char sexe[MAX_PERS]; /* C standard */
etc ...

3) Schéma d'un tableau :

On représente un tableau comme une commode à plusieurs tiroirs
dont chaque tiroir contient un seul objet de même type :


T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
age[0] Q% 45 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
age[1] Q% 20 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
age[2] Q% 27 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
age[3] Q% 49 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
...... Q% ... Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
...... Q% .... Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
age[14] Q% 21 Q%


4) Manipulations d'un tableau :

1. On crée souvent des tableaux en lisant un ou plusieurs
fichiers de données. La boucle while est fréquente :

Exemple :
......

int n = 0 ; /* compteur */

while ( !feof(donnees) ) {

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

n++ ;
}
fclose (donnees);


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


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

3. Sur l'en-tête des fonctions, on n'a pas besoin de
mentionner les bornes des tableaux à un seul indice :

float moyenne ( float t[], int n )
/* Cette fonction calcule et retourne la valeur
moyenne d'un tableau t qui contient n réels */

......

void trier ( int age[], float taille[], int nbPers)


4. Le nom d'un tableau n'est pas du tout une variable. C'est
une constante de type pointeur : c'est l'adresse de son
premier élément indice 0.

float taille[10] ;

taille est équivalent à &taille[0]

Ainsi taille = ..... ; est toujours invalide
(on affecte à une variable, pas à une constante).


5. En C, on peut déclarer et initialiser un tableau :

#define NB_NOTES 7

float bareme[NB_NOTES] = { 100.0, 100.0, 25.0, 35.0, 40.0,
100.0, 100.0 } ;

Ainsi, bareme[0] vaut 100.0 (on corrige l'intra sur 100)
bareme[1] vaut 100.0 (on corrige le final sur 100)
bareme[2] vaut 25.0 (on corrige le TP1 sur 25)
etc ....

6. En C, si t est le nom d'un tableau, on a :

t + i &t[i]
* (t + i) t[i]

7. On peut utiliser des pointeurs pour manipuler un tableau.
Cependant, il est souhaitable d'être d'abord capable de
manipuler les indices avant d'utiliser des pointeurs qui,
eux provoquent souvent des erreurs si on ne maîtrise pas
bien le concept des pointeurs.

Exemples : Écrire une fonction qui affiche le contenu du
tableau des tailles à l'écran :

a. avec les indices (plus simples à comprendre)

void afficher ( float taille[], int nbPers )
{ int i ;

for ( i = 0 ; i < nbPers ; i++ )
printf("%3d) %8.2f\n", i, taille[i]) ;
}

b. avec un pointeur (un peu plus compliqué)


void afficher ( float * P, int nbPers )
{ int i ;

for ( i = 0 ; i < nbPers ; i++ )
printf("%3d) %8.2f\n", i, *(P+i) ) ;
}

OU (encore plus compliqué) :

void afficher ( float * P, int nbPers )
{ int i ;

while ( i < nbPers )
printf("%3d) %8.2f\n", i++, *P++ ) ;
}

L'utilisation de pointeur est plus fréquente dans le
traitement des chaînes de caractères (sous forme tableau des
caractères ou pointeur vers le type caractère).

5) Exemples et exercices :

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

On dispose du fichier texte "Mesures.Dta". Chaque ligne de ce
fichier contient les informations d'une seule personne: sa
taille et son poids.

On a 20 personnes ou moins dans le fichier.

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

Pour 17 personnes lues dans le fichier:

1. La taille
- moyenne : 1.68 mètre
- la plus grande : 1.83 mètre
- la plus petite : 1.43 mètre


2. Le poids
- moyen : 61.69 kgs
- le plus lourd : 86.20 kgs
- le plus léger : 42.50 kgs


Solution :


/* Fichier Tableau1.C
Matière principale : tableaux à un seul indice

Données : "Mesures.Dta" (une taille et un poids par ligne)
1.63 54.9
1.57 56.3
1.73 63.0
etc ...
*/

#include

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

void creer ( float taille[], float poids[], int * P )
{
FILE * aLire = fopen("Mesures.Dta", "r");
int n = 0 ;
while ( !feof(aLire) ) {
fscanf(aLire, "%f%f\n", &taille[n], &poids[n]);
n++;
}
fclose (aLire);
*P = n ;
}
/* Cette fonction permet de calculer la valeur moyenne
/ d'un tableau t qui contient exactement n réels. */

float moyenne ( float t [], int n )
{
float somme = 0.0 ;

int i ;

for ( i = 0 ; i < n ; i++ ) somme += t[i];

return somme / n ;
}

/* Cette fonction détermine la plus grande et la plus
petite valeur dans un tableau T de N réels. */

void determiner ( float t[], int n, float * PG, float * PP )
{
float plusGrande = t[0] ,
plusPetite = t[0] ;

int i ;

for ( i = 1 ; i < n ; i++ ) {

if ( t[i] > plusGrande ) plusGrande = t[i] ;
if ( t[i] < plusPetite ) plusPetite = t[i] ;
}

*PG = plusGrande ;
*PP = plusPetite ;
}

void main()
{
float taille [MAX_PERS],
poids [MAX_PERS] ;
int nbPers ;

float grandeTaille, petiteTaille,
lourdPoids , legerPoids ;

creer (taille, poids, &nbPers) ;

printf("Pour %d personnes lues dans le fichier:\n\n", nbPers);

determiner (taille, nbPers, &grandeTaille, &petiteTaille);

printf(" 1. La taille\n");

printf(" - moyenne : %6.2f mètre\n",
moyenne(taille, nbPers));

printf(" - la plus grande : %6.2f mètre\n", grandeTaille);
printf(" - la plus petite : %6.2f mètre\n", petiteTaille);
printf("\n\n");
determiner (poids, nbPers, &lourdPoids, &legerPoids);

printf(" 2. Le poids\n");

printf(" - moyen : %6.2f kgs\n",
moyenne(poids, nbPers));

printf(" - le plus lourd : %6.2f kgs\n", lourdPoids);
printf(" - le plus léger : %6.2f kgs\n", legerPoids);

}


Exercice 1 :


Ajouter au programme de l'exemple 1 (exemple précédent) :

1. une fonction avec l'en-tête suivant :
void afficher ( float taille[], float poids[], int nbPers )
et un appel de cette fonction pour afficher le contenu
de ces deux tableaux à l'écran .

2. une fonction avec l'en-tête suivant :
void afficher2( float * P, float * S, int n )
et un appel de cette fonction pour afficher le contenu
des 5 premiers éléments des deux tableaux taille et poids
à l'écran .

Exemple 2 (tri d'un tableau) :

Soit t un tableau de n réels (par exemple). Écrire un bloc
d'instructions permettant de trier le tableau t selon la
méthode du tri par sélection (vue au cours préalable IFT 1810) :

Solution :

int i, j, indMinimum ;
float temporaire ;

for ( i = 0 ; i < n - 1 ; i++ ) /* du premier à avant dernier */
{
indMinimum = i ;

for ( j = i + 1 ; j < n ; j++ )
if (t[j] < t[indMinimum]) indMinimum = j ;

if ( indMinimum != i ) { /* on échange */

temporaire = t[i] ;
t[i] = t[indMinimum] ;
t[indMinimum] = temporaire ;
}
}


notes :

1) on va réviser en classe cette méthode de tri ;
2) on apprendra une autre méthode de tri rapide.


Exemple 3 (recherche avec une sentinelle) :


Programmer l'algorithme suivant qui permet de chercher un
élément dans un tableau (trié ou non) :


Soit t un tableau de n éléments (triés ou non). Soit
aChercher une valeur à chercher. L'algorithme de la
recherche avec une sentinelle se présente comme suit :

indice = -1
t[n] = aChercher

Répéter
indice = indice + 1
Jusqu'à t[indice] = aChercher

Si indice < n on trouve à "indice"
Sinon on ne trouve pas.

Solution :

void chercher ( int t[], int n, int aChercher, int * P )
{
int indice = -1 ;

t[n] = aChercher ;

do
indice++ ;
while (t[indice] != aChercher) ;

*P = indice ;
}

Exemple d'utilisation :

/* Chercher un numéro donné dans un tableau des numéros
de nbEmp employés : */

#define MAX_EMP 1250
int unNumero, numero[MAX_EMP] ;
int nbEmp, indice ;

.......

printf("Quel est le numéro de l'employé recherché ? ");
scanf("%d", &unNumero);

chercher ( numero, nbEmp, unNumero, &indice) ;
if (indice == nbEmp )
printf("Désolé! on ne le trouve pas %d\n", unNumero);
else
{ printf("Son numéro : %d\n", numero[indice]);
printf("son âge : %d\n", age [indice]);
etc ....
}


Exercice 2 (recherche dichotomique dans un tableau trié) :


Le tableau devrait être trié avant d'appliquer cette méthode.
Soit le bloc d'instructions suivant qui résume la méthode de
recherche dichotomique dans un tableau trié :


#define VRAI 1
#define FAUX 0

int indice , mini, maxi, milieu , trouve ;

trouve = FAUX ; /* on ne trouve pas encore */

mini = 0 ;
maxi = N - 1 ; /* on examine tout le tableau */

while ( !trouve && (mini t[milieu] )
mini = milieu + 1 ;
else
trouve = VRAI ;
}

if (trouve) indice = milieu ;
else
printf("On ne le trouve pas!\n");


Simuler le programme avec le tableau t qui contient 7 éléments.
( n = 6 ). La valeur recherchée est :

a) 27

b) 100

c) 50




T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[0] Q% 5 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[1] Q% 20 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[2] Q% 27 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[3] Q% 49 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[4] Q% 79 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[5] Q% 90 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%
t[6] Q% 100 Q%
T%P%P%P%P%P%P%P%P%P%P%P%P%P%P%P%W%


Exercice 3 (fusion de deux tableaux triés) :

Écrire une fonction qui fusionne deux tableaux d'entiers ordonnés
en un seul tableau ordonné. Écrire un programme pour tester le bon
fonctionnement de votre fonction.

6) Exemple de révision :


On dispose du fichier texte "Employes.Dta". Chaque ligne de ce fichier
contient les informations d'un seul employé. On y trouve :

- le poste de travail : un caractère :
'A' pour analyste
'P' pour programmeur
'O' pour opérateur
'S' pour secrétaire

- le numéro d'employé : un entier
- le nombre d'heures de travail: un réel
- le taux d'horaire : un réel

On a 250 employés ou moins dans le fichier.

Contenu du fichier :

P 2754 40.01 19.01
P 1848 40.02 23.01
S 2636 32.50 12.00
A 1750 30.03 25.16
A 2168 33.04 25.20
O 4612 42.00 10.12
etc ....


Écrire un programme en C qui permet :

- de lire le fichier, de mémoriser les données dans 3 tableaux :
poste, numero, salHebdo (salaire hebdomadaire)

- d'offrir un menu et traiter le choix de l'usager :

. afficher la liste des employés
. trier selon les numéros des employés
. rechercher un employé (recherche avec 1 sentinelle si le
tableau n'est pas encore trié et recherche dichotomique
si le tri est fait)
. calculer et afficher quelques statistiques


Une solution possible :

/* Fichier : Tableaux.C

Objectifs pédagogiques : revoir presque toutes les matières
vues au cours IFT 1810, cours
préalable au langage C.

Données : Employes.Dta contenant moins de 250 employés

*/

#include
#include /* pour la Conversion de type (ex. toupper(...))*/

#define MAX_EMP 250 /* au maximum, 250 employés */

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Auteur : Jean, CHOQUETTE Date : ...... 20xx +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ But de cette fonction : +
+ La fonction permet de calculer et de retourner le meilleur +
+ salaire hebdomadaire d'un poste de travail donné (voulu) +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Paramètres d'entrée : Le tableau des salaires hebdo. +
+ Le nb. d'employés N +
+ Le poste voulu : un caractère +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Appel par la fonction principale +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/

float meilleur( float salHebdo[],char poste[], int n, char posteVoulu)
{ float plusGrand = 0;
int i ;

for (i = 0 ; i < n ; i++)
if (poste[i] == posteVoulu)
if (salHebdo[i] > plusGrand) plusGrand = salHebdo[i] ;

return plusGrand ;
}
void obtenir(char * C)
{ char leChoix ;
int valide ; /* Oui ou Non le choix est valide */

printf("Tapez :\n");

printf(" - A pour visualiser\n");
printf(" - T pour trier\n");
printf(" - C pour rechercher\n");
printf(" - S pour statistiques\n");
printf(" - Q pour quitter\n");

do {
printf("\nVotre choix parmi A, T, C, S ou Q ");
fflush(stdin);
leChoix = toupper(getchar());

valide = ( leChoix == 'A' || leChoix == 'T' ||
leChoix == 'C' || leChoix == 'S' ||
leChoix == 'Q' );
if (!valide)
printf("votre choix est imprévu, retapez S.V.P. ");

} while (!valide);
*C = leChoix ;
}

/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Auteur : Lise, LALIBERTE Date : ...... 20xx +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ But de cette fonction : +
+ La fonction permet de lire le fichier Employes.Dta, de remplir +
+ les 3 tableaux et de compter le nb. effectif d'employés lus +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Paramètres d'entrée : Aucun +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Paramètres de sortie : Les trois tableaux, +
+ un paramètre transmis par pointeur pour +
+ le nb. effectif d'employés lus +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Appel par la fonction principale +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
*/

void lireCreer ( char poste[], int numero[], float salHebdo[], int * P)

{ int n = 0 ; /* compteur du nombre effectif d'employés lus
déclarer et "initialiser" (style courant de C) */

float nbHr, taux ;
FILE * donnees ;
donnees = fopen("Employes.Dta", "r");



if (donnees == NULL)
printf("Problème d'ouverture du fichier à lire!\n");
else {
while (!feof(donnees)) {
fscanf(donnees,"%c%d%f%f\n", &poste[n], &numero[n],
&nbHr, &taux);
salHebdo[n] = nbHr * taux ;
n++;
};
fclose(donnees);
*P = n ;
}
}

/* afficher "explicitement" un poste de travail
Matières pédagogiques : sélection multiple avec switch */

void ecrire (char unposte)
{
switch (unposte) {

case 'A' : printf(" Analyste"); break ;
case 'P' : printf(" Programmeur"); break ;
case 'O' : printf(" Opérateur"); break ;
case 'S' : printf(" Secrétaire");
}
printf("\n");
}

void afficher ( char poste[], int numero[], float salHebdo[], int n )
{ const int parEcran = 20 ;
int i ;

printf("Liste d'employés :\n");

for (i = 0 ; i < n ; i++)
{
printf("%4d) %5d %7.2f", i+1, numero[i], salHebdo[i]);

ecrire(poste[i]);

if ( (i + 1) % parEcran == 0 || i == (N-1))
{

printf("\nAppuyez sur Q pour quitter ");
if ( i < N-1 ) printf(" ou Entrée pour continuer ");
fflush(stdin);
if (toupper(getchar()) == 'Q') break ;
}
}
}








void demander(int * P)
{
printf("Quelques numéros existants : 4371, 1750, 2325, 3215\n");

printf("Quel est le numéro de l'employé recherché ? ");
scanf("%d", P);
}

void chercherSenti (int aChercher, int numero[], int nbEmpl, int * P)
{ int indice ;

printf("\nRecherche séquentielle avec une sentinelle :\n\n");

indice = - 1 ;
numero[nbEmpl] = aChercher ;

do indice++;
while ( numero[indice] != aChercher );

if (indice == nbEmpl) indice = -1 ;

*P = indice ;
}

void continuer()
{ printf("\n\nAppuyez sur Entrée ");
fflush(stdin);
getchar();
}

void chercherDicho (int aChercher, int numero[], int nbEmpl,
int * P)
{ int mini, maxi, milieu ;

int trouve ; /* Oui (1) ou Non (0) on trouve le numéro recherché*/
printf("\nRecherche dichotomique dans un tableau trié:\n\n");

mini = 0 ;
maxi = nbEmpl - 1 ;
trouve = 0 ; /* on ne trouve pas encore */

while ( !trouve && mini numero[milieu])
mini = milieu + 1 ;
else
trouve = 1 ; /* on trouve! */
}

if (!trouve) *P = -1 ;
else *P = milieu ;

}


void trier ( char poste[], int numero[], float salHebdo[],
int nbEmpl)
{ int i, j, indMin ;
int tempoNum ;
float tempoSal ;
char tempoPost ;

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

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

if ( indMin != i ) {

tempoNum = numero[i];
numero[i] = numero[indMin];
numero[indMin] = tempoNum ;

tempoSal = salHebdo[i] ;
salHebdo[i] = salHebdo[indMin] ;
salHebdo[indMin] = tempoSal ;

tempoPost = poste[i] ;
poste[i] = poste[indMin] ;
poste[indMin] = tempoPost ;
}
}
}


void main()
{

char poste[MAX_EMP] ;

int numero[MAX_EMP] ;

float salHebdo[MAX_EMP] ;

int nbEmpl ;

char choix ;
int dejaTrie = 0 ; /* Faux au début */

int aChercher, indice ;

lireCreer ( poste, numero, salHebdo, &nbEmpl );

do {
obtenir (&choix);
switch (choix) {
case 'A' : afficher ( poste, numero, salHebdo, nbEmpl ); break;

case 'S' :
printf("meilleur salaire :\n");
printf(" - des analystes : %8.2f $\n",
meilleur(salHebdo, nbEmpl, 'A'));
printf(" - des opérateurs: %8.2f $\n",
meilleur(salHebdo, nbEmpl, 'O'));
continuer();
break ;

case 'C' : demander(&aChercher);
if(dejaTrie)
chercherDicho(aChercher, numero, nbEmpl, &indice);
else
chercherSenti(aChercher, numero, nbEmpl, &indice);

if (indice >= 0)
{ printf("Yahou!, on le trouve :\n");
printf("%5d %7.2f", numero[indice],
salHebdo[indice]);
ecrire(poste[indice]);
}
else printf("Désolé, on ne trouve pas %d\n", aChercher);

continuer();
break ;

case 'T' : trier ( poste, numero, salHebdo, nbEmpl);
dejaTrie = 1 ;
break ;
}
} while (choix != 'Q');
}

Exécution :

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q a

Liste d'employés :
1) 2754 760.59 Programmeur
2) 1848 920.86 Programmeur
3) 2636 390.00 Secrétaire
4) 1750 755.55 Analyste
5) 2168 832.61 Analyste
6) 4612 425.04 Opérateur
7) 2325 405.20 Opérateur
8) 1512 811.76 Analyste
9) 2340 762.58 Analyste
10) 3428 925.34 Programmeur
11) 3563 487.50 Secrétaire
12) 4101 422.50 Secrétaire
13) 4371 645.85 Programmeur
14) 3629 967.21 Programmeur
15) 2630 606.42 Programmeur
16) 3215 807.82 Programmeur
17) 3529 454.52 Opérateur
18) 1538 929.19 Programmeur
19) 4119 879.70 Analyste
20) 4121 648.59 Programmeur

Appuyez sur Q pour quitter ou Entrée pour continuer
21) 1023 857.11 Analyste
22) 1868 390.00 Secrétaire
23) 1944 390.00 Secrétaire
24) 1430 610.19 Programmeur
25) 3727 892.56 Programmeur
26) 4613 451.50 Opérateur
27) 3628 452.36 Opérateur
28) 4368 453.22 Opérateur
29) 2047 487.50 Secrétaire
30) 2565 422.50 Secrétaire
31) 3026 855.40 Programmeur
32) 4342 847.79 Analyste
33) 2451 822.76 Analyste
34) 1741 436.65 Opérateur
35) 1957 422.50 Secrétaire
36) 1327 853.75 Analyste
37) 1631 487.50 Secrétaire
38) 1644 390.00 Secrétaire
39) 2028 462.25 Opérateur
40) 2021 422.50 Secrétaire

Appuyez sur Q pour quitter ou Entrée pour continuer q

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q s

meilleur salaire :
- des analystes : 1217.20 $
- des opérateurs: 760.59 $

Appuyez sur Entrée

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q c

Quelques numéros existants : 4371, 1750, 2325, 3215

Quel est le numéro de l'employé recherché ? 2325

Recherche séquentielle avec une sentinelle :

Yahou!, on le trouve :
2325 405.20 Opérateur

Appuyez sur Entrée

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q c

Quelques numéros existants : 4371, 1750, 2325, 3215

Quel est le numéro de l'employé recherché ? 5555

Recherche séquentielle avec une sentinelle :

Désolé, on ne trouve pas 5555

Appuyez sur Entrée

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter


Votre choix parmi A, T, C, S ou Q t

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q c

Quelques numéros existants : 4371, 1750, 2325, 3215

Quel est le numéro de l'employé recherché ? 3215

Recherche dichotomique dans un tableau trié:

Yahou!, on le trouve :
3215 807.82 Programmeur
Appuyez sur Entrée

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q c

Quelques numéros existants : 4371, 1750, 2325, 3215

Quel est le numéro de l'employé recherché ? 6789

Recherche dichotomique dans un tableau trié:

Désolé, on ne trouve pas 6789


Appuyez sur Entrée

Tapez :
- A pour visualiser
- T pour trier
- C pour rechercher
- S pour statistiques
- Q pour quitter

Votre choix parmi A, T, C, S ou Q q

7) Tableau dynamique :

Si les données dépassent 64 kilo-octets, il est préférable d'utiliser
un tableau dynamique où les données seront mémorisées en zone de
mémoire dynamique.

Seules la déclaration et la demande d'allocation d'espace de mémoire
sont différentes :

const int MAX_EMP = 5000;

float * salHebdo ;

salHebdo = (float *) malloc (sizeof(float) * MAX_EMP);

Une fois que le tableau a été déclaré et que l'espace de mémoire
dynamique a été alloué, il suffit d'utiliser des indices pour
manipuler ce tableau dynamique :

salHebdo[23] désigne le salaire hebdomadaire du 24 ième employé, etc.

B) Les tableaux à deux indices en C :

La plupart des applications des tableaux à 2 indices sont en
calcul matriciel (mathématiques). Pour le cours IFT 1160, nous
nous limitons à un exemple simple : gestion des notes du cours
IFT 1160.

1) Déclaration du tableau des notes :

On peut déclarer un seul tableau à 2 indices pour les notes où :

note [23] [0] vaut 82.7

signifie que la première note (indice 0) du 24 ième étudiant
(indice 23) vaut 82.7.

Le premier indice désigne le rang de l'étudiant ( la note de qui ? )
Le deuxième indice désigne la catégorie de note ( pour quelle note ? ).


#define MAX_ETUD 100 /* 100 étudiants ou moins */

#define NB_NOTES 7 /* 7 notes (intra, final, tp1, tp2, tp3,
tps et globale) */

float note [MAX_ETUD] [NB_NOTES] ;

2) Manipulation :

1. On utilise aussi la boucle for.

2. On écrit : note [12] [3], on n'écrit pas note [12, 3].

3. Sur l'en-tête d'une fonction, il faut donner au moins la
deuxième borne :

void afficher ( float note [] [NB_NOTES], int nbEtud)

3) Exemple :

Écrire une fonction et 2 appels de cette fonction pour afficher
à l'écran :

- la moyenne d'intra (indice 0)
- la moyenne du final (indice 1)

Solution :


float moyenne ( float note[] [NB_NOTES], int nbEtud, int catVoulu )

{ float somme = 0.0 ;
int i ;

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

somme += note [i] [catVoulu] ;

return somme / nbEtud ;
}


Appels :

printf("La moyenne d'intra : %6.2f\n", moyenne(note, nbEtud, 0) );
printf("La moyenne du final : %6.2f\n", moyenne(note, nbEtud, 1) );


Exercices :

Exercice 1 (pour les étudiants en sciences mathématiques) :

Écrire un programme qui comporte des fonctions pour tester les
calculs matriciels :

- l'addition de deux matrices
- la multiplication de deux matrices
- la transposition d'une matrice
- etc ...


Exercice 2 (carré magique) :


Écrire un programme permettant de fabriquer et d'afficher les
carrés magiques d'ordre impair entre 3 et 15.

Exemple :

Carré magique d'ordre 3 :

8 1 6
3 5 7
4 9 2


(La solution sera donnée si l'exercice vous intéresse).


Chapitre 3 : Les tableaux Page  PAGE 73