Les tableaux et leur parcours
Ce que ce chapitre apporte 4 points
- Expliquer ce qu'est un tableau, et reconnaître quand il devient nécessaire : pour revenir sur des valeurs déjà lues.
- Créer un tableau, lire et modifier une case par son indice, sans jamais sortir de ses bornes.
- Parcourir un tableau avec une boucle dont la borne est longueur(t).
- Reconnaître et écrire les trois traitements de base : accumuler, chercher, compter.
Un technicien relève la température d'un atelier chaque jour à midi, et veut savoir combien de jours ont été plus chauds que la moyenne de la série. La question paraît simple, et elle oblige pourtant à revenir sur des valeurs déjà lues : il faut tout lire pour connaître la moyenne, puis relire chaque mesure pour la comparer. Comment garder une série entière sous la main, et la parcourir autant de fois qu'il le faut ?
Cinq mesures, c'est cinq variables. Cent mesures, c'est intenable. Le tableau range plusieurs valeurs sous un seul nom, chacune repérée par son indice, et c'est ce qui permet de revenir sur une série déjà lue : calculer une moyenne, puis compter les mesures qui la dépassent, demande de relire la série une seconde fois. La boucle du chapitre précédent fait le reste, avec son compteur pour indice et l'accumulateur qu'elle a déjà employé, et la condition du chapitre sur les tests décide, case par case, de ce qui compte. Un parcours tient alors en trois lignes, quel que soit le nombre de valeurs.
Jusqu'ici, chaque variable rangeait une seule valeur. Or les données d'un problème réel arrivent souvent en série : les températures d'une semaine, les débits d'une pompe relevés heure par heure, les diamètres d'un lot de pièces. Ce chapitre les range dans un tableau, puis montre les trois traitements qui reviennent sans cesse sur une série : accumuler, chercher, compter.
Qu'est-ce qu'un tableau ?
Un tableau est une structure qui regroupe plusieurs valeurs sous un seul nom. Chaque valeur est appelée un élément, et elle est repérée par un indice, sa position dans le tableau. Dans ce cours, le premier élément porte l'indice 1.
On peut se représenter un tableau comme une rangée de cases numérotées : chaque case contient une valeur, et son numéro permet de la retrouver ou de la modifier sans confondre les cases. Voici les températures relevées à midi, cinq jours de suite, rangées dans un tableau :
| Indice | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| Valeur | 12 | 7 | 15 | 9 | 18 |
Si ce tableau s'appelle releves, releves[1] désigne le premier élément, 12, releves[2] le deuxième, 7, et ainsi de suite jusqu'à releves[5], qui vaut 18. Un tableau se crée directement avec ses valeurs, écrites entre crochets et séparées par des virgules :
programme principal
Cinq variables séparées, t1 ← 12, t2 ← 7, et ainsi de suite, rangeraient les mêmes valeurs. Mais un nom de variable ne se calcule pas, alors qu'un indice, si : releves[i] désigne une case différente selon la valeur de i. C'est ce qui permettra à une boucle de passer d'une case à la suivante, et ce qui fait tout l'intérêt du tableau.
Le pseudo-code du cours l'accepte, comme Python : aucun type n'est déclaré, et chaque case a le type de la valeur qui y est rangée, nombre, texte ou booléen. D'autres langages, comme C ou Java, l'interdisent. En pratique, un tableau range des valeurs de même nature, les mesures d'une série, et c'est ce qui permet de leur appliquer à toutes le même traitement.
Dans la convention de ce cours, releves[1] désigne quoi ?
Créer un tableau, lire et modifier ses cases
Quand les valeurs ne sont pas encore connues, un tableau se crée avec sa seule taille, puis se remplit case par case :
programme principal
tableau[3] ne désigne pas une case : c'est l'ordre de réserver trois cases, vides. Au premier pas, la figure les montre marquées d'un point d'interrogation. Les trois lignes suivantes les remplissent, une par une ; une case se lit ensuite, ou se modifie, par son indice, sans toucher aux autres. Ici, le deuxième relevé était faux, et seule sa case change. Lire une case avant d'y avoir rangé une valeur arrête l'algorithme, comme lire une variable jamais affectée.
Additionner les cases une à une, releves[1] + releves[2] + releves[3], reste possible pour trois valeurs ; pour cent, non. C'est le travail de la boucle.
Dans ce cours, les indices commencent toujours à 1. En Python, en C ou en Java, comme dans Flowgorithm, le parcours suivant, ils commencent à 0 : le premier relevé s'y écrit releves[0], et le cinquième releves[4]. C'est à la traduction que le décalage se produit le plus souvent. Le parcours d'architecture montre pourquoi la machine, elle, compte à partir de 0 : l'indice y devient une distance à l'adresse du tableau.
Parcourir un tableau avec une boucle
Le compteur d'une boucle Pour peut servir d'indice : à chaque tour, releves[i] désigne une autre case, et la boucle visite ainsi tout le tableau, dans l'ordre. Reste à savoir jusqu'où aller.
longueur(releves) rend le nombre de cases du tableau releves. C'est une fonction fournie par le langage : elle reçoit un tableau et rend un nombre ; le chapitre suivant montre comment en écrire soi-même.
L'employer comme borne, plutôt qu'un nombre écrit à la main, garantit que la boucle visite toutes les cases et aucune de plus, quelle que soit la taille du tableau. Pour i de 1 à longueur(releves) est l'écriture à retenir, et celle qu'emploient tous les chapitres suivants.
programme principal
i prend successivement les valeurs 1 à 5, et chaque tour lit une nouvelle case. Un relevé de huit jours s'afficherait en entier sans qu'aucune autre ligne ne change.
Dans ce cours, un tableau de cinq cases a des indices de 1 à 5 : releves[0] et releves[6] n'existent pas. Un tableau créé avec ses valeurs, comme [12, 7, 15, 9, 18], ou avec sa taille, comme tableau[5], a un nombre de cases fixé : lire ou écrire hors de ces bornes arrête l'algorithme. C'est le dépassement de tableau, et il vient presque toujours d'une borne décalée d'un cran : Pour i de 0 à 5 commence une case trop tôt, Pour i de 1 à 6 finit une case trop tard.
programme principal
La figure additionne les cinq relevés sans encombre, puis s'arrête au sixième tour, sur releves[6]. En Python, les mêmes cinq cases portent les indices 0 à 4, et releves[5] y désigne justement la case qui n'existe pas. Avec longueur(releves) pour borne, l'erreur ne peut pas se produire.
1.Pourquoi un tableau plutôt que cinq variables t1 à t5 ?
2.Lire releves[6] dans un tableau de cinq cases donne quoi ?
Les trois traitements de base
Presque tout ce qu'on fait d'une série se ramène à trois gestes : accumuler les valeurs, chercher l'une d'elles, compter celles qui vérifient une condition. Ils se ressemblent, et ne se préparent pas de la même façon.
Accumuler : la somme et la moyenne
programme principal
somme part de zéro avant la boucle, puis chaque tour y ajoute une case : on dit qu'elle accumule les valeurs. Le tableau de trace le montre tour par tour :
| Tour | i | releves[i] | somme en fin de tour |
|---|---|---|---|
| 1 | 1 | 12 | 12 |
| 2 | 2 | 7 | 19 |
| 3 | 3 | 15 | 34 |
| 4 | 4 | 9 | 43 |
| 5 | 5 | 18 | 61 |
La moyenne se calcule après la boucle, une fois la somme complète : 61 divisé par 5, soit 12,2 degrés. La division / rend un nombre décimal, même entre deux entiers.
Ce type de traitement montre la force des boucles : une seule structure traite une série de n'importe quelle taille. Encore faut-il que la taille ne soit écrite nulle part. Avec 5 dans la borne et 5 dans le diviseur, passer à cent valeurs oblige à modifier deux lignes, et n'en corriger qu'une donne une moyenne fausse sans que rien ne le signale. Avec longueur(releves) aux deux endroits, il n'y a plus rien à modifier.
Chercher : le maximum, et sa position
programme principal
L'algorithme commence par supposer que la première valeur est la plus grande (max ← releves[1]), puis parcourt le reste du tableau, de la case 2 à la dernière, en comparant chaque valeur au maximum retenu ; une valeur plus grande prend sa place. En déroulant, max ne change que deux fois en quatre tours : quand i vaut 3 (15 remplace 12) et quand i vaut 5 (18 remplace 15). Un parcours ne modifie pas à chaque pas. Le minimum se cherche de la même façon, en retournant la comparaison.
Partir de la première valeur n'est pas un détail. Partir de zéro échouerait sur un relevé d'hiver, où toutes les températures sont négatives : le maximum resterait zéro, une valeur qui n'est pas dans le tableau. Et sur un tableau vide, releves[1] n'existe pas : un algorithme qui peut recevoir un tableau vide doit le tester avant de commencer.
Pour savoir où se trouve le maximum, il suffit de retenir son indice plutôt que sa valeur : rang ← 1 avant la boucle, puis rang ← i chaque fois qu'une case dépasse releves[rang]. releves[rang] en donne alors la valeur.
programme principal
Le tri par sélection du chapitre Les algorithmes de tri repose sur ce geste, appliqué au minimum.
1.Pour additionner tous les éléments d'un tableau, que faut-il préparer avant la boucle ?
2.Pour chercher le maximum d'un tableau, par quoi commencer ?
Compter, en revenant sur les valeurs
Jusqu'ici, chaque traitement aurait pu se faire au fil de la saisie, sans rien garder : additionner ou chercher un maximum ne demande qu'une variable, et le chapitre précédent faisait une moyenne avec un Lire dans la boucle. Le tableau devient indispensable dès qu'il faut repasser sur les valeurs. Pour savoir combien de jours ont été plus chauds que la moyenne, il faut d'abord connaître la moyenne, donc avoir tout lu, puis relire chaque valeur pour la comparer : deux parcours du même tableau.
programme principal
La seconde boucle compte : audessus part de zéro avant la boucle, comme un accumulateur, mais n'augmente que dans le Si, d'une unité à la fois. Compter, c'est accumuler des 1 sous condition. La figure trouve deux jours au-dessus de la moyenne de 12,2 degrés, ceux à 15 et à 18 ; le premier jour, à 12 degrés, reste en dessous, de peu.
Quand un tableau devient-il indispensable ?
Chercher une valeur, et s'arrêter dès qu'on l'a trouvée
Chercher le maximum oblige à tout regarder. Chercher si une valeur est présente, ou où apparaît pour la première fois une valeur qui dépasse un seuil, permet de s'arrêter dès qu'on l'a trouvée. C'est un TantQue, dont la condition réunit les deux raisons de continuer : il reste des cases à examiner, et rien n'a encore été trouvé.
programme principal
Lire reçoit » : la recherche s'arrête dès le jour 1, et le total de pas affiché à droite des boutons tombe à 10, contre 18 pour le seuil 14. Saisir ensuite 15 : le jour 3 vaut exactement 15 degrés, la comparaison stricte > l'écarte, et la réponse devient le jour 5, en 26 pas. Saisir enfin 18 : le dernier relevé atteint ce seuil sans le dépasser, et le message devient « Aucun jour au-dessus de 18 degrés ». Comparer les totaux : chaque case écartée coûte quatre pas de plus, et c'est ce que la recherche économise en s'arrêtant dès qu'elle a trouvé.
trouve est un témoin : il vaut Faux avant la recherche et passe à Vrai dès que la case examinée dépasse le seuil, tandis que i n'avance que tant que rien n'est trouvé. La condition i <= longueur(releves) ET NON trouve se lit : il reste des cases, et rien n'est encore trouvé. La figure s'arrête ainsi au jour 3, sans regarder les deux derniers.
Remplacer 14 par 20 dans les entrées : aucun jour ne dépasse ce seuil, la boucle examine les cinq cases et s'arrête avec i égal à 6, une case après la dernière. C'est pourquoi le résultat se lit dans trouve, jamais dans releves[i], dont la lecture arrêterait l'algorithme. Cette recherche séquentielle est celle que le chapitre Diviser pour régner compare à la dichotomie.
Pourquoi cette recherche s'écrit-elle avec un TantQue plutôt qu'avec un Pour ?
Mettre en pratique
Chaque traitement de base se prévoit à la main sur un petit tableau, avant de faire confiance à la boucle. Les questions suivantes portent sur le relevé de vibrations de l'exercice 3.
Ce que donne un parcours, case par case
- 1.
Le capteur a relevé
[8, 12, 10, 15, 3, 11]. Que vautsommeà la sortie de la boucle qui accumule ces mesures ? - 2.
Quelle moyenne l'algorithme en tire-t-il ?
- 3.
La recherche du maximum part de
max ← vibrations[1], puis parcourtPour i de 2 à longueur(vibrations). Combien de comparaisons fait-elle ? - 4.
La recherche à témoin de la dernière section cherche dans ce relevé une mesure strictement supérieure à 20. Que vaut
ià la sortie de la boucle ? - 5.
Compter les mesures au-dessus de la moyenne oblige à deux parcours. Combien de lectures de case l'algorithme fait-il en tout ?
- 6.
Traduit en Python, où les indices commencent à 0, quel indice désigne la case
vibrations[6]du cours ?
Chercher d'abord, ouvrir le corrigé ensuite. Les trois exercices reprennent les trois traitements du chapitre : accumuler, chercher, compter.
Un contrôleur mesure la longueur de plusieurs pièces usinées, en millimètres. Lire leur nombre, puis les mesures, et afficher la longueur moyenne, puis l'écart de chaque pièce à cette moyenne.
programme principal
Les écarts ne peuvent se calculer qu'une fois la moyenne connue, donc après avoir tout lu : c'est ce qui oblige à garder les mesures dans un tableau, et à le parcourir deux fois. Le tableau mesures n'est pas créé avec une taille : il naît de sa première case, mesures[1], et grandit d'une case à chaque tour de lecture. C'est une façon de remplir un tableau dont la taille n'est connue qu'à l'exécution ; l'autre est de réserver les cases une fois n lu, avec mesures ← tableau[n].
Dans le relevé des températures d'une semaine, trouver la plus basse, et le premier jour où elle a été relevée.
programme principal
Retenir l'indice plutôt que la valeur donne les deux réponses d'un coup : releves[rang] est le minimum, rang le jour. La comparaison stricte < garde le premier des deux jours à -5 degrés, le quatrième : avec <=, le cinquième jour remplacerait le quatrième, et la réponse deviendrait le jour 5.
Initialiser le minimum à 0 plutôt qu'à la première valeur. Sur un relevé d'été, où toutes les températures sont strictement positives, l'algorithme répondrait 0, une température qui n'a jamais été relevée. On part toujours de la première valeur réelle.
Un capteur de vibrations a relevé six mesures, rangées dans un tableau : 8, 12, 10, 15, 3, 11. Compter celles qui dépassent le seuil d'alerte, fixé à 10.
programme principal
alertes est initialisé avant la boucle et augmenté dans le Si. Placé en dehors du Si, il compterait toutes les mesures, et pas seulement celles qui dépassent le seuil.
Voici le tableau de trace du même parcours, à comparer avec ce que montre la figure, pas à pas :
i | vibrations[i] | > 10 ? | alertes |
|---|---|---|---|
| 1 | 8 | non | 0 |
| 2 | 12 | oui | 1 |
| 3 | 10 | non (10 n'est pas > 10) | 1 |
| 4 | 15 | oui | 2 |
| 5 | 3 | non | 2 |
| 6 | 11 | oui | 3 |
Résultat : 3. Le tour où i vaut 3 mérite l'attention : > est strict, et la mesure égale au seuil ne déclenche pas d'alerte. Si la consigne voulait « atteint ou dépasse », il fallait écrire >=. C'est le genre de détail qui fait toute la différence entre un algorithme juste et un algorithme presque juste.
Chapitre révisé en octobre 2026 · Une erreur dans ce chapitre ?
Dans la bibliothèque d'exercices
Indices et bornes, les trois parcours utiles, et le maximum qu'on ne cherche pas depuis zéro.
- Indices et bornes2 · Appliquer
- Parcourir et résumer2 · Appliquer
- Chercher sans partir de zéro3 · Combiner
- Le total d'un tableau3 · Combiner
- La case qui n'existe pas4 · Analyser
- Chercher une valeur dans un tableau4 · Analyser