Tableaux
Objectifs du Chapitre
Comprendre la notion de tableau et son utilité.
Savoir déclarer, remplir et parcourir un tableau.
Maîtriser les notions d’indice, de taille et d’accès aux éléments.
Être capable de traiter des séries de données à l’aide de boucles.
Cinq notes, c'est cinq variables. Cent notes, c'est intenable. Le tableau range plusieurs valeurs sous un seul nom, chacune repérée par son indice, et c'est ce qui rend enfin utile la boucle du chapitre précédent : parcourir, additionner, chercher un maximum se font alors en trois lignes quel que soit le nombre de valeurs.
Qu’est-ce qu’un tableau ?
Un tableau est une structure qui regroupe plusieurs valeurs du même type sous un seul nom. Chaque valeur du tableau est appelée un élément, et elle est repérée par un indice (ou position).
On peut imaginer un tableau comme une rangée de boîtes alignées sur une étagère :
chaque boîte contient une valeur (par exemple une note), et chaque boîte porte un numéro d’ordre, appelé indice.
Ce numéro permet de retrouver ou de modifier facilement le contenu de chaque case sans les confondre.
| Indice | Élément |
|---|---|
| 1 | 12 |
| 2 | 15 |
| 3 | 18 |
Ainsi, si l’on appelle ce tableau notes, on peut accéder :
- au premier élément avec
notes[1], - au deuxième avec
notes[2], - au troisième avec
notes[3].
Chaque valeur est indépendante, mais toutes partagent le même nom, ce qui simplifie leur manipulation.
Exemple
Cet algorithme affiche la première note contenue dans le tableau. L’intérêt du tableau est qu’il permet de rassembler plusieurs données dans une même variable, tout en gardant la possibilité d’y accéder individuellement.
Par exemple, au lieu de créer trois variables séparées :
on peut simplement écrire :
et manipuler les valeurs de manière beaucoup plus flexible.
On peut comparer cela à un casier à compartiments : chaque compartiment contient une donnée, et l’étiquette du casier (l’indice) permet de la retrouver rapidement.
C’est ce principe qui rend les tableaux essentiels dans la programmation : ils servent à stocker, parcourir et traiter efficacement une série de données.
Avant de continuer
- À quoi sert un tableau par rapport à plusieurs variables séparées ?
- Que représente l’indice dans un tableau ?
- Peut-on mélanger des types différents (nombres, textes, booléens) dans un même tableau ?
Déclaration et utilisation
La création d’un tableau dépend du langage, mais le principe reste le même :
on déclare un nom et une taille (le nombre d’éléments que l’on veut stocker).
Ici, le tableau notes peut contenir 5 valeurs (par exemple les notes de 5 élèves). Chaque case est indépendante et peut être remplie, lue ou modifiée à tout moment.
Une fois les valeurs enregistrées, on peut les utiliser librement dans les calculs ou les affichages :
Le tableau fonctionne donc comme une liste de tiroirs numérotés :
- on ouvre un tiroir grâce à son indice,
- on regarde ce qu’il contient,
- ou on remplace la valeur par une autre.
Cela permet d’accéder rapidement à une donnée précise sans devoir chercher dans tout le programme.
Exemple complet
Dans cet exemple, on crée un tableau de trois notes. On affiche d’abord la deuxième, puis on la modifie avant de la réafficher. Le tableau permet donc d’enregistrer et de mettre à jour facilement plusieurs valeurs sans multiplier les variables.
Les indices d’un tableau commencent souvent à 1 dans le pseudo-code, mais dans la plupart des langages de programmation (comme Python, C ou Java), ils commencent à 0. Cela signifie que le premier élément d’un tableau notes est notes[0] dans ces langages. Il est donc important de bien vérifier le point de départ des indices selon le langage utilisé, afin d’éviter des erreurs de décalage ou des accès hors limites.
Parcours d’un tableau avec une boucle
La boucle Pour est idéale pour parcourir un tableau, car le nombre d’éléments est connu à l’avance.
On utilise alors la variable du compteur comme indice pour accéder à chaque case du tableau une à une.
Exemple
Ici, la boucle passe dans chaque case du tableau et affiche la valeur qu’elle contient. La variable i prend successivement les valeurs 1, 2, 3, 4 et 5, ce qui permet à l’algorithme de visiter chaque élément dans l’ordre. Chaque tour de boucle correspond à la lecture d’une nouvelle case.
On peut imaginer le parcours d’un tableau comme une personne qui feuillette un carnet de notes : à chaque page (chaque indice), elle lit une valeur, puis tourne la page suivante jusqu’à la fin du carnet. Ce mécanisme rend les tableaux particulièrement puissants pour automatiser des tâches répétitives.
Exemple d’utilisation pratique
Parcourir un tableau ne sert pas seulement à afficher des valeurs : on peut aussi effectuer des calculs à chaque passage. Voici un algorithme qui calcule la somme de toutes les notes :
Le compteur i permet d’accéder à chaque case dans l’ordre et d’ajouter la valeur correspondante à la variable somme. On peut ensuite calculer la moyenne, le maximum ou toute autre statistique à partir des mêmes données.
Cette méthode évite de répéter manuellement les instructions et garantit un code plus court, plus clair et plus fiable.
Si la taille du tableau est connue, utilisez directement sa longueur dans la boucle :
Cela rend l’algorithme plus flexible : si le tableau contient plus ou moins d’éléments, la boucle s’adapte automatiquement sans qu’il soit nécessaire de modifier les bornes.
Si l’on essaie d’accéder à un indice en dehors du tableau (par exemple notes[6] alors que le tableau ne contient que 5 éléments), l’algorithme provoque une erreur.
Il faut donc toujours s’assurer que l’indice reste compris entre la première et la dernière case.
On parle alors de dépassement de tableau, une erreur très courante lorsqu’on oublie que les indices commencent souvent à 0 dans les vrais langages de programmation.
En résumé, la boucle Pour est l’outil naturel pour explorer un tableau, élément par élément. Elle transforme un ensemble de données en une séquence d’actions ordonnées, ce qui ouvre la voie à des traitements plus complexes comme les recherches, les tris ou les filtrages.
4. Traitements courants sur les tableaux
Les tableaux deviennent vraiment puissants lorsqu’ils sont associés à des boucles.
Grâce à elles, il est possible d’effectuer automatiquement des calculs sur plusieurs valeurs : somme, moyenne, maximum, minimum, etc.
L’algorithme peut ainsi analyser, résumer ou comparer de grandes quantités de données sans répétition inutile.
Calcul de la somme des éléments
Ici, on initialise une variable somme à 0, puis on ajoute chaque élément du tableau à cette variable. À chaque itération, somme grandit un peu plus, jusqu’à contenir la somme totale de toutes les notes. On dit que somme accumule les valeurs une à une.
On peut comparer ce processus à une boîte de collecte : à chaque tour de boucle, on y dépose une nouvelle valeur, et à la fin, la boîte contient le total de tout ce qui a été ajouté.
Calcul de la moyenne
Le calcul de la moyenne reprend le même principe : on additionne toutes les valeurs, puis on divise la somme par le nombre d’éléments du tableau.
Ce type de traitement montre bien la force des boucles : une seule structure permet de traiter des ensembles de données de n’importe quelle taille. Si le tableau contient 100 valeurs au lieu de 4, il suffit de modifier la borne de la boucle, le reste du programme reste identique.
Si la taille du tableau n’est pas connue à l’avance, on peut remplacer le nombre 4 par une fonction longueur(notes). Ainsi, l’algorithme s’adaptera automatiquement à la taille réelle du tableau :
Recherche du maximum
Ici, l’algorithme cherche la plus grande valeur du tableau. On commence par supposer que le premier élément est le plus grand (max ← notes[1]), puis on parcourt le reste du tableau en comparant chaque nouvelle valeur avec le maximum actuel. Si une valeur est plus grande, on met à jour max. À la fin, max contient la valeur la plus élevée.
Cette méthode est un exemple classique de parcours séquentiel : on passe en revue chaque élément, on compare, et on garde la meilleure valeur trouvée. Elle illustre parfaitement la puissance de la combinaison “tableau + boucle”.
On peut étendre ce principe pour chercher :
- le minimum, en inversant la condition,
- la position (indice) du maximum,
- ou même plusieurs valeurs extrêmes (par exemple les deux plus grandes notes).
5. À toi de jouer
Cherche d'abord, ouvre le corrigé ensuite. Les trois exercices reprennent, dans l'ordre, les trois traitements de ce chapitre : parcourir, accumuler, compter.
Exercice 1 : lire les notes de 5 élèves, les stocker dans un tableau, puis afficher la moyenne.
Afficher la solution
On lit et on additionne dans la même boucle : inutile de parcourir le tableau une seconde fois. Attention au diviseur, c'est le nombre de notes (5), pas la dernière valeur de i.
Exercice 2 : demander 10 nombres et afficher le plus grand.
Afficher la solution
Initialiser max ← 0 au lieu de max ← valeurs[1]. Si toutes les valeurs saisies sont négatives, l'algorithme répond 0, qui n'a jamais été saisi. On part toujours de la première valeur réelle.
Exercice 3 : parcourir un tableau de 6 valeurs et compter combien sont supérieures à 10.
Afficher la solution
Le compteur est initialisé avant la boucle et incrémenté dans le Si. Le placer en dehors du Si compterait toutes les valeurs, pas seulement celles qui dépassent 10.
Déroulons sur valeurs = [8, 12, 10, 15, 3, 11] :
| i | valeurs[i] | > 10 ? | compteur |
|---|---|---|---|
| 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. Note la ligne 3 : > est strict, 10 ne compte pas. C'est le genre de détail qui fait toute la différence entre un algorithme juste et un algorithme presque juste.
- Un tableau regroupe plusieurs valeurs du même type sous un seul nom.
- Chaque valeur est repérée par son indice.
- Les boucles permettent de parcourir les éléments un à un.
- Les trois traitements de base sont toujours les mêmes : accumuler (somme, moyenne), chercher (maximum, minimum), compter (combien vérifient une condition).
Et ensuite ? Le chapitre Fonctions montre comment donner un nom à un traitement pour ne l'écrire qu'une fois, puis l'appeler autant de fois qu'on veut.