Chapitre 7 Corrige
Chapitre 7 Corrige
Chapitre 7 Corrige
Tableaux
7.1 Introduction
Les variables que nous avons utilisées jusqu’à maintenant ne permettent de stocker qu’une
seule donnée. A chaque fois que l’on souhaitait stocker une donnée on créait donc une variable.
Exemple : Pour stocker le score d’un joueur on crée une variable scoreJoueur ; pour stocker le
score de deux joueurs, on crée deux variables : scoreJoueur1 et scoreJoueur2.
Si cette méthode est adaptée tant que le nombre de données à stocker est faible, elle n’est en
revanche plus envisageable si le nombre de données devient très grand. Par exemple si l’on doit
stocker le score de 1000 joueurs, il n’est pas réaliste d’envisager de créer 1000 variables différentes
pour cela. Dans ce cas, on utilise une structure de donnée que l’on appelle tableau.
Remarque : Lorsque le nombre de données de même type à stocker devient important il faut
penser à utiliser un tableau et non plus des variable atomiques. On peut considérer qu’à partir de
5 valeurs, le nombre de valeurs est important.
Déclarer une variable tableau revient à regrouper dans une même variable (un seul nom de
variable) un nombre déterminé d’éléments de même type plutôt que de déclarer X variables (de
noms différents) de ce type.
Exemple :
– Toutes les notes obtenues par l’étudiant Dupond en BdP pour l’année 2014.
– Toutes les températures relevées à midi tous les jours de l’année 2014.
– Tous les codes des articles qui sont vendus dans un magasin.
À retenir : Un tableau ne permet de regrouper que des valeurs de même type.
� �
1 type nomTableau[nbElements];
121
IUT de Villetaneuse
� �
Exemple :
� �
1 int tab[12];
réserve en mémoire un tableau de 12 éléments (i.e., cases) pouvant contenir des valeurs de type
int (entières) et associe ce tableau au nom de variable tab.
À retenir : La taille du tableau, c’est-à-dire le nombre d’éléments du tableau, doit être une
constante, et non une variable - i.e. un littéral.
Attention : Comme pour les autres types de variables, il n’y a pas de valeur par défaut dans les
cases du tableau. Il peut donc y avoir n’importe quelle valeur !
Il est possible, lors de la déclaration d’un tableau (et uniquement à ce moment là), d’initialiser
le tableau, c’est-à-dire de donner une valeur à chaque élément du tableau. Pour cela, il faut donner
� �
ces valeurs entre accolades. Ainsi, l’instruction
� �
1 int tab[3] = {1, 3, 5};
� �
1 int tab[6] = {2, 3};
� �
correspond à l’instruction
� �
1 int tab[6] = {2, 3, 0, 0, 0, 0};
� �
1 int tab[] = {18, 32, 23, 1, 0};
correspond à un tableau de 5 éléments dont les éléments sont initialisés avec les valeurs données
entre accolades.
Attention : Il n’est pas possible d’initialiser un tableau avec un autre tableau. Ainsi, le code
� �
suivant est incorrect :
1 int tab[] = {1, 2, 3};
� �
2 int t2[] = tab; //Impossible
Remarque : Comme pour les autres types de variables, une variable de type tableau est détruite
dès que le programme rencontre l’accolade fermante correspondant au bloc d’instructions où la
variable est déclarée.
� Sur ce thème : Exercice 7
� �
1 nomTableau[indice];
Chaque élément d’un tableau peut être vu comme une variable (c’est une zone mémoire dans
laquelle on stocke une donnée). On peut donc affecter une valeur à un élément du tableau ou se
� �
servir de la valeur stockée dans un tableau pour un calcul ou un affichage. L’exécution du code :
1 int main()
2 {
3 int tab[3] = {45, 5, 1};
4
5 cout << "le premier élément du tableau tab est : " << tab[0] << endl;
6 cout << "le deuxième élément du tableau tab est : " << tab[1] << endl;
7 cout << "le troisième élément du tableau tab est : " << tab[2] << endl;
8
9 tab[0]=25;
10 tab[0]+=tab[1];
11
12 cout << "le premier élément du tableau tab est maintenant : " << tab[0] << endl;
13 return 0;
� �
14 }
Attention : Hormis lors de sa déclaration, une variable de type tableau ne peut être à gauche
d’une affectation sans être indicée (c’est-à-dire suivie d’un indice entre crochets). Le code suivant
� �
est incorrect.
1 int tab[12];
2 tab = {1,2,3}; //Incorrect car permis uniquement lors de la déclaration
� �
3 tab[0] = 18; //Correct car on a tab[0] (et non tab)
� �
Exemple : Parcours dans l’ordre croissant :
1 int main()
2 {
3 int tab[5]={6,78,99,4,5}; /* initialisation du tableau */
4 int i = 0;
5 while (i<5) /* parcourir tous les éléments effectifs du tableau */
6 {
7 tab[i]+=2; /* incrémenter de 2 l’élément i du tableau tab */
8 cout << tab[i] << endl;
� �
1er semestre �123 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
9 i++;
10 }
11
12 return 0;
� �
13 }
� �
Exemple : Parcours dans l’ordre décroissant :
1 int i=4;
2 while (i>=0)
3 {
4 tab[i]=tab[i]+2; /* incrémenter de 2 l’élément i du tableau tab */
5 cout << tab[i] << endl;
6 i--;
� �
7 }
7
6
101
80
8
� Sur ce thème : Exercice 1, TD 4, Question 1.4
� Sur ce thème : Exercice 3 et 4, TD 4
� �
Intro à l’algorithmique et à la programmation �124 � 1er semestre
Departement informatique
13 cout << "Veuillez saisir le nombre de valeurs à stocker (entre 1 et 1000) :"<< endl ;
14 saisie(nbSaisies) ;
15 }
16
26 //A ce moment là, nbElementsTableau correspond au nombre de valeurs stockées dans le tableau
27 cout << "nombre d’éléments dans le tableau : "<< nbElementsTableau << endl;
28
� �
37 }
Il faut donc bien différencier le nombre de valeurs possibles que l’on peut stocker dans le
tableau (correspondant à la taille du tableau donnée lors de sa déclaration), le nombre de valeurs
que l’on voudra stocker dans le tableau lors d’une exécution de l’algorithme et le nombre de cases
effectivement utilisées durant l’algorithme pour stocker des valeurs du programme.
Dans l’exemple précédent,
1000 est la taille du tableau. C’est l’espace mémoire qui a été attribué à la variable tableau lors
de sa déclaration ligne 4. Cette taille définie le nombre maximal de valeurs qui peuvent être
stockées dans ce tableau.
nbSaisies est le nombre de valeurs que l’on envisage de placer dans ce tableau de 1000 cases. Il
faut impérativement s’assurer que ce nombre de valeur est bien inférieur à la capacité du
tableau (ligne 11)
nbElementsTableau est le nombre de cases effectivement utilisées dans le tableau. Au départ,
quand aucune valeur n’a encore été mise en mémoire dans le tableau nbElementsTableau,
elle vaut 0. Elle est donc initialisé à 0 (ligne 18), puis elle doit être mise à jour explicitement
lors de chaque ajout ou retrait d’une valeur du tableau par incrémentation ou décrémentation
(ligne 23).
Remarque : Quand on remplit itérativement le tableau, la variable nbElementsTableau indique
l’indice de la prochaine case à "remplir".
En C++ on définit les constantes nommées au moyen de la déclaration d’une macro de la façon
� �
suivante :
� �
1 #define NOM_DE_LA_CONSTANTE_EN_MAJUSCULE valeur
Cette instruction est à placer en en-tête du programme (avant les fonctions que vous définissez
et avant le main()).
À retenir : Par convention les noms des constantes sont donnés en MAJUSCULES pour bien
mettre en évidence leur caractère particulier.
Cette constante, ainsi définie, est alors accessible n’importe où dans le programme ! Sa portée
n’est pas limitée. En fait, il ne s’agit pas d’une variable mais d’un code qui sera traité par le
préprocesseur. Chaque occurrence de la macro (le nom de la constante) sera remplacée avant
compilation par sa valeur. Dans le code compilé c’est la valeur qui apparait. Dans le code écrit
c’est le nom de la macro (ce qui est plus explicite).
Remarque : Lorsqu’on définit en C++ des tableaux de taille fixe, il est d’usage de paramétrer
leur taille maximale (leur capacité) par une constante nommée. On peut alors faire référence à
cette taille limite par un nom de constante explicite, plutôt que par un nombre magique
� �
Exemple : Pour reprendre l’exemple précédent, cela donnerait :
3 int main ()
4 {
5 int tableau[TAILLE_TAB_MAX];
6
7 [...]
8
17 [...]
18
19 return 0;
� �
20 }
Attention : Dans l’en-tête, il ne faut absolument rien mettre entre les crochets. Lors d’un appel
de la fonction, la valeur du paramètre de type tableau sera le nom de la variable (de type tableau)
sans les crochets !
� �
Intro à l’algorithmique et à la programmation �126 � 1er semestre
Departement informatique
De plus, si l’on a besoin dans la fonction de connaître la taille du tableau (pour le parcourir
par exemple), il faut alors passer un deuxième paramètre de type int à cette fonction. À l’appel,
� �
sa valeur sera la taille du tableau passé en paramètre.
1 // La fonction affiche reçoit l’adresse du tableau et sa taille
2 void affiche_tableau(int tab[], int taille)
3 {
4 int i = 0;
5 while (i<taille)
6 {
7 cout << tab[i] << endl;
8 i++;
9 }
10 }
11
12 int main()
13 {
14 int tabint1[] = {3, 7, 2, 6, 1, 45, 23} ;
15 int tabint2[] = {23, 5, 40, 8, -2, 39, -31,25, 62, 12 };
16 int longtab1 = 7 ; // longueur de tabint1
17 int longtab2 = 10 ; // longueur de tabint2
18
19 affiche_tableau(tabint1, longtab1) ;
20 affiche_tableau(tabint2, longtab2) ;
21 return 0;
� �
22 }
3
7
2
6
1
45
23
23
5
40
8
-2
39
-31
25
62
12
Attention : Lorsque l’on passe un tableau en paramètre d’une fonction, les modifications des
éléments du tableau effectuées par les instructions de la fonction sont répercutées dans le reste du
programme.
À retenir : Du point de vue pratique, on retiendra que l’on peut modifier les éléments d’un
� �
tableau passé en paramètre. On peut écrire par exemple :
1 void incremente_tableau(int tab[], int taille)
2 {
3 int i = 0;
4
� �
1er semestre �127 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
12 int main()
13 {
14 int tabint1[] = {3, 7, 2, 6, 1, 45, 23} ;
15
18 incremente_tableau(tabint1, longtab1);
19 affiche_tableau(tabint1, longtab1) ;
20
21 return(0);
� �
22 }
� �
Intro à l’algorithmique et à la programmation �128 � 1er semestre
Departement informatique
Question 1.2 : [Indice et valeur] Quelle différence y a-t-il entre l’indice d’un élément d’un tableau
et sa valeur ?
Correction :
Ce sont deux choses différentes. L’indice est un entier correspondant à la position de l’élément dans un tableau
alors que la valeur est une donnée (nombre, chaîne de caractères, etc) stockée dans le tableau. �
Question 1.3 : Déclarer un tableau de nombres réels double précision de taille 6 qui sera initialisé
avec des valeurs quelconques.
Question 1.4 : Afficher le tableau à l’endroit puis à l’envers.
� �
Correction :
1 int main ()
2 {
3 double tab[] = {1.2, 2.3, 4.3, -6.6, 9., -23.3};
4
� � �
21 }
� �
1er semestre �129 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
5 bool ok = true;
6
15 if (!ok)
16 cout << "non" << endl;
17 else
18 cout << "oui" << endl;
19
20 return 0;
� � �
21 }
3 int main ()
4 {
5 int t[TAILLE_TAB] = {32, 5, 12, 83, 3, 75, 2, 15};
6 int i = 1;
7 int plusgrand = t[0];
8
16 cout << "le plus grand element du tableau a la valeur " << plusgrand << endl;
17 return 0;
� � �
18 }
� Exercice 4 : (suite) **
Question 4.1 : Écrire un programme affichant le plus grand entier pair contenu dans un tableau
d’entiers strictement positifs. Attention, si le tableau ne contient aucun entier pair, le programme
doit afficher le message Le tableau ne contient aucun entier pair.
� �
Correction :
1 #define TAILLE_MAX 10
2
3 int main ()
� �
Intro à l’algorithmique et à la programmation �130 � 1er semestre
Departement informatique
4 {
5 int tab[TAILLE_MAX] = {5, 8 , 98, 45, 89, 102, 56, 111, 79, 51};
6 int i=0;
7
8 //Affichage du tableau
9 cout << "Affichage du tableau : " << endl ;
10
17 i = 0;
18 int plusGrandEntierPair = 0;
19
27 if (plusGrandEntierPair)
28 cout << "Le plus grand entier pair est:" << plusGrandEntierPair << endl ;
29 else
30 cout << "Le tableau ne contient pas de nombre pair "<< endl ;
31
32 return 0;
� �
33 }
�
Question 4.2 : Modifier le programme ci-dessus pour qu’il prenne en compte n’importe quel type
d’entier (positif ou négatif)
� �
Correction :
1 #define TAILLE_MAX 10
2 int main ()
3 {
4 int tab[TAILLE_MAX] = {-5, 8 , 98, 45, -89, -102, 56, 1111, -79, 51};
5 int i=0;
6
7 //Affichage du tableau
8 cout << "Affichage du tableau : " << endl ;
9
� �
1er semestre �131 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
23 i++;
24 }
25
26 if (IndplusGrandEntierPair !=-1)
27 cout << "Le plus grand entier pair est:" << tab[IndplusGrandEntierPair] << endl ;
28 else
29 cout << "Le tableau ne contient pas de nombre pair "<< endl ;
30 return 0;
� � �
31 }
15 int main ()
16 {
17 int tab [TAILLE_MAX] = {5,6,8,14,17};
18 cout << "la somme est :" << somme(tab,TAILLE_MAX) << endl;
19 return 0;
� � �
20 }
Exercice 6 : Rotations **
Ecrire un programme qui permet d’effectuer une rotation à droite des éléments d’un tableau
d’entiers, quelque soit le nombre d’éléments qu’il contient.
Exemple d’affichage attendu :
Avant rotation a droite
{15, -10, 70, 74, 12, 20}
Apres rotation a droite
{20, 15, -10, 70, 74, 12}
Correction :
� �
On peut passer rapidement sur l’affichage !
1 #define TAILLE_MAX 6
2
3 int main()
4 {
� �
Intro à l’algorithmique et à la programmation �132 � 1er semestre
Departement informatique
7 // Affichage
8 cout << "Avant rotation a droite" << endl ;
9 int i=0;
10 while ( i < TAILLE_MAX)
11 {
12 cout << tab[i] << " , " ;
13 i++ ;
14 }
15 cout << endl ;
16
17 // Rotation
18 int aux=tab[TAILLE_MAX-1];
19 i = TAILLE_MAX - 1;
20 while (i>=1)
21 {
22 tab[i]=tab[i-1];
23 i--;
24 }
25 tab[0]=aux;
26
27 // Affichage
28 cout << "Apres rotation a droite" << endl ;
29 i=0;
30 while ( i < TAILLE_MAX)
31 {
32 cout << tab[i] << " , " ;
33 i++ ;
34 }
35 cout << endl ;
36 return 0;
� � �
37 }
� �
1er semestre �133 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
� �
Correction :
1 int main()
2 {
3 int tabint[2] = {1} ;
4 cout << "-" << tabint[1] << "-" << endl;
5
18 return 0;
� � �
19 }
� �
Correction :
1 void affiche_tableau(double tab[], int taille)
2 {
3 int i = 0;
4 while (i<taille)
5 {
6 cout << tab[i] << endl;
7 i++;
8 }
9 }
10
11 int main()
12 {
13 double tab[10] = {3.,2.65,7.0,-9.5};
14 affiche_tableau(tab, 4);
� �
Intro à l’algorithmique et à la programmation �134 � 1er semestre
Departement informatique
� � �
18 }
Question 8.2 : Définir une fonction moyenneTab prenant en paramètre un tableau de réels et
retournant la moyenne des nombres du tableau. Testez la fonction !
� �
Correction :
1 double moyenneTab(double tab[], int taille)
2 {
3 double somme=0;
4 int i =0;
5 while (i<taille)
6 {
7 somme += tab[i];
8 i++;
9 }
10 return somme/ taille ;
11 }
12
13 int main()
14 {
15 double tab[10] = {3.,2.65,7.0,-9.5};
16 moyenneTab(tab, 4);
17 cout << "moy = " << moyenneTab(tab, 4) << endl;
18 return 0;
� � �
19 }
Question 8.3 : Définir une fonction minMax prenant en paramètre un tableau de réels (et bien sûr
sa taille) et deux paramètres réels min et max. La fonction déterminera le minimum et le maximum
des éléments du tableau et modifiera les paramètres min et max en conséquence. La fonction ne
retournera aucune valeur.
� �
Correction :
1 void minMax(double tab[], int taille, double & min, double & max)
2 {
3 min = tab[0];
4 max = tab[0];
5 int i =1;
6 while (i<taille)
7 {
8 if (tab[i] < min)
9 min = tab[i];
10
17 int main()
18 {
19 double min ;
20 double max ;
21 double tab[10] = {3.,2.65,7.0,-9.5};
� �
1er semestre �135 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
� � �
26 }
Question 8.4 : Définir une fonction saisieNotes prenant en paramètre un tableau de réels (mais
pas sa taille). La fonction permettra à un utilisateur de saisir les notes d’un étudiant et de les
stocker dans le tableau passé en paramètre. La saisie s’arrête lorsque l’utilisateur a saisi un nombre
strictement inférieur à 0 ou strictement supérieur à 20. La fonction retournera le nombre de notes
saisies par l’utilisateur.
� �
Correction :
1 int saisieNotes(double tab[])
2 {
3 int taille = 0;
4 double nb;
5 cout << "Saisissez une note : " ;
6 saisie( nb );
7 while (nb >= 0.0 && nb <= 20.0)
8 {
9 tab[taille] = nb ;
10 taille++;
11 cout << "Saisissez une note : " ;
12 saisie( nb );
13 }
14 return taille;
� � �
15 }
Question 8.5 : Écrire le programme principal en utilisant les fonctions définies précédemment.
Le tableau de notes sera déclaré comme un tableau de taille 1000 afin de s’assurer que l’utilisa-
teur ne dépasse pas la capacité du tableau. Si l’utilisateur ne saisit aucune note, le programme
devra afficher Aucune note n’a été saisie pour l’étudiant au lieu des minimum, maximum
et moyenne. Ajouter également la mention de l’étudiant : redoublement (< 10), passable (entre 10
et 12), assez-bien (entre 12 et 14), bien (entre 14 et 16) et très bien (supérieur ou égal à 16).
� �
Correction :
1 int main ()
2 {
3 double notes[10000] ;
4 int nbNotes = saisieNotes(notes);
5
6 if (nbNotes > 0 )
7 {
8 affiche_tableau(notes, nbNotes) ;
9 double min,max;
10 minMax(notes,nbNotes,min,max);
11 cout << "la note minimale : " << min << endl;
12 cout << "la note maximale : " << max << endl;
13
� �
Intro à l’algorithmique et à la programmation �136 � 1er semestre
Departement informatique
29 return 0;
� � �
30 }
Question 8.6 : Remplacer les nombres magiques par des constantes nommées si cela n’a pas été
fait.
� �
Correction :
1 #define MAX_SIZE 10000
2
3 int main ()
4 {
5
6 double notes[MAX_SIZE] ;
7 int nbNotes = saisieNotes(notes);
8
9 //...
10
11 return 0;
� � �
12 }
� � �
9 }
� �
1er semestre �137 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
� � �
9 }
Question 9.3 : ** Écrire une fonction qui reçoit un tableau d’entiers et sa taille, et qui renvoie
vrai ou faux selon que le tableau est trié dans l’ordre croissant ou non.
� �
Correction :
1 bool est_trie(int tab[], int lon)
2 {
3 int i = 1 ;
4 while (i<lon)
5 {
6 if (tab[i]<tab[i-1])
7 return false ;
8 i++;
9 }//fin du while
10 return true ;
� � �
11 }
� �
Correction :
1 int main(void)
2 {
3 srand(time(NULL));
4
5 int tabint[25] ;
6 initAlea(tabint,25);
7 affichetab(tabint, 25);
8 if (est_trie(tabint, 25))
9 cout <<"Dans l’ordre croissant" << endl;
10 else
11 cout << "Pas dans l’ordre" << endl;
12 return 0;
� � �
13 }
Question 9.5 : *** Écrire une fonction inserer qui reçoit un tableau d’entiers et sa taille. Le
tableau est trié dans l’ordre croissant, sauf le dernier élément qui peut être n’importe quoi. La
fonction met le dernier élément à sa place par rapport au reste sans rien perdre, de façon que
le tableau soit trié (cela s’appelle insérer le dernier élément). Tester la fonction précédente sur
quelques exemples.
� �
Correction :
1 void insere(int tab[], int lon)
2 {
3 int i = lon - 2 ;
4 int tmp = tab[lon -1] ;
5 bool fait = false ;
6 while (i >= 0 && ! fait)
7 {
8 if (tmp < tab[i])
� �
Intro à l’algorithmique et à la programmation �138 � 1er semestre
Departement informatique
9 tab[i+1] = tab[i];
10 else
11 {
12 tab[i+1] = tmp ;
13 fait = true ;
14 }
15 i-- ;
16 }//fin du while
17 if (! fait)
18 tab[0] = tmp ;
� � �
19 }
Question 9.6 : * Modifier le programme principal afin de trier le tableau à l’aide de la fonction
inserer.
� �
Correction :
1 int i = 1;
2 while (i<=25)
3 {
4 insere(tabint,i);
5 i++;
6 }
� � �
7 affichetab(tabint, 25) ;
7 if (deuxfois)
8 cout << "Il y a une répétition" << endl ;
9 else
� � �
10 cout << "Il n’y a pas de répétition" << endl;
� Exercice 10 : **
Question 10.1 : ** En modifiant légèrement les fonctions de l’exercice précédent, écrire un
programme qui permet de trier un tableau de 5 prénoms par ordre alphabétique, les noms étant
saisis par l’utilisateur.
Correction :
C’est la même chose que l’exercice précédent, il faut juste remplacer les paramètres type tableau d’entiers par
tableaux de string. �
Question 10.2 : ** Modifier ce programme en triant les prénoms par taille. Pour ce dernier vous
pouvez utiliser la fonction int size(string s) qui permet de retourner la taille d’une chaîne.
� �
Correction :
1 void insere(string tab[], int lon)
� �
1er semestre �139 � Intro à l’algorithmique et à la programmation
IUT de Villetaneuse
2 {
3 int i = lon - 2 ;
4 string tmp = tab[lon -1] ;
5 int fait = 0 ;
6 while (i >= 0 && ! fait)
7 {
8 if (size(tmp) < size(tab[i]))
9 tab[i+1] = tab[i];
10 else
11 {
12 tab[i+1] = tmp ;
13 fait = 1 ;
14 }
15 i-- ;
16 }//fin du while
17 if (! fait)
18 tab[0] = tmp ;
� � �
19 }
� �
Intro à l’algorithmique et à la programmation �140 � 1er semestre