Chapitre 5 — Les tableaux et la manipulation de collections de données

Qu’est-ce qu’un tableau ?

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.

Début
    notes ← [12, 15, 18]
    Écrire "Première note :", notes[1]
Fin

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 :

note1 ← 12
note2 ← 15
note3 ← 18

on peut simplement écrire :

notes ← [12, 15, 18]

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.

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).

notes ← tableau[5]

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.

notes[1] ← 10
notes[2] ← 12
notes[3] ← 15
notes[4] ← 9
notes[5] ← 13

Une fois les valeurs enregistrées, on peut les utiliser librement dans les calculs ou les affichages :

Écrire "Note du 3e élève : ", notes[3]
Écrire "Moyenne de la classe : ", (notes[1] + notes[2] + notes[3] + notes[4] + notes[5]) / 5

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.

Début
    notes ← tableau[3]
    notes[1] ← 14
    notes[2] ← 9
    notes[3] ← 16
    Écrire "Deuxième note :", notes[2]
    notes[2] ← 12
    Écrire "Note modifiée :", notes[2]
Fin

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.

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.

Début
    notes ← [12, 15, 18, 10, 14]
    Pour i de 1 à 5
        Écrire "Note ", i, " : ", notes[i]
    FinPour
Fin

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 :

Début
    notes ← [12, 15, 18, 10, 14]
    somme ← 0
    Pour i de 1 à 5
        somme ← somme + notes[i]
    FinPour
    Écrire "Somme totale : ", somme
Fin

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 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

Début
    notes ← [10, 12, 15, 13]
    somme ← 0
    Pour i de 1 à 4
        somme ← somme + notes[i]
    FinPour
    Écrire "Somme totale : ", somme
Fin

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

Début
    notes ← [10, 12, 15, 13]
    somme ← 0
    Pour i de 1 à 4
        somme ← somme + notes[i]
    FinPour
    moyenne ← somme / 4
    Écrire "Moyenne : ", moyenne
Fin

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.

moyenne ← somme / longueur(notes)

Recherche du maximum

Début
    notes ← [10, 12, 15, 13]
    max ← notes[1]
    Pour i de 2 à 4
        Si notes[i] > max Alors
            max ← notes[i]
        FinSi
    FinPour
    Écrire "Note maximale : ", max
Fin

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. Applications directes

Exercice 1 : Écrire un algorithme qui lit les notes de 5 élèves, les stocke dans un tableau, puis affiche la moyenne.

Exercice 2 : Écrire un algorithme qui demande 10 nombres et affiche le plus grand d’entre eux.

Exercice 3 : Écrire un algorithme qui parcourt un tableau de 6 valeurs et compte combien sont supérieures à 10.

Ces exercices vous aideront à pratiquer les boucles combinées aux tableaux, deux outils essentiels pour automatiser le traitement de données répétitives.