Skip to main content
Back to path

Welcome to a Grasp lesson

Create a free account to keep studying and create your own study path.

Lesson 33

Manipulation de tableaux 2D par indexation

Recommended resources

Bonjour ! Bienvenue dans cette nouvelle leçon.

Dans le module précédent, nous avons appris à structurer nos algorithmes en fonctions pour les rendre plus clairs et modulaires. Cette organisation logique est cruciale. Maintenant, nous allons enrichir notre boîte à outils en apprenant à organiser nos données de manière plus complexe.

La leçon précédente s'est terminée en évoquant les tableaux à deux dimensions. Aujourd'hui, nous plongeons au cœur de ce sujet. L'objectif est d'apprendre à déclarer et à manipuler ces structures, aussi appelées matrices, en accédant à leurs éléments par des indices de ligne et de colonne. C'est la base pour traiter des données organisées en grille, comme des feuilles de calcul, des plateaux de jeu ou des images.

1. Des listes aux grilles : Introduction aux tableaux 2D

Vous vous souvenez des tableaux à une dimension (Module 4) ? Ils sont parfaits pour stocker une liste d'éléments, comme les notes d'un étudiant : Notes[0], Notes[1], Notes[2], ....

Mais que faire si nous voulons stocker les notes de plusieurs étudiants dans une seule structure ? Ou les pixels d'une image, qui sont organisés en lignes et en colonnes ? Nous avons besoin d'une structure de données en forme de grille : c'est le rôle du tableau à deux dimensions.

Une excellente analogie est celle d'une image numérique. Une image est simplement une grille de pixels. Pour identifier un pixel, il faut deux informations : sa ligne et sa colonne.

[PDF] Les tableaux 2D

Le document '[PDF] Les tableaux 2D' de Ph. Langlois commence par cette analogie très visuelle. Il montre comment une image peut être représentée par un tableau 2D.

Lisez les diapositives 2 à 4. Concentrez-vous sur la diapositive 4, qui compare la représentation 1D et 2D d'une simple image. Remarquez comment le tableau 2D t[ligne, colonne] rend la structure de l'image beaucoup plus intuitive.

Comme vous l'avez vu, un tableau à deux dimensions est essentiellement un "tableau de tableaux". On peut l'imaginer comme un ensemble de lignes, où chaque ligne est elle-même un tableau.

2. Déclaration d'un tableau à deux dimensions (Matrice)

Pour déclarer un tableau 2D en pseudo-code, nous devons spécifier deux tailles : le nombre de lignes et le nombre de colonnes. La syntaxe est une extension naturelle de celle des tableaux 1D.

Si un tableau 1D de N éléments se déclare ainsi (avec des indices de 0 à N-1) :
Var MonTableau : tableau [0..N-1] de Type

Un tableau 2D avec L lignes et C colonnes se déclare comme suit :
Var MaMatrice : tableau [0..L-1, 0..C-1] de Type

  • L est le nombre de lignes. Les indices de ligne iront de 0 à L-1.
  • C est le nombre de colonnes. Les indices de colonne iront de 0 à C-1.
  • Type est le type de données que la matrice contiendra (entier, réel, caractère, etc.).

Exemple concret :
Pour stocker les notes de 30 étudiants dans 5 matières différentes, nous pourrions utiliser une matrice de 30 lignes et 5 colonnes.

Var NotesClasse : tableau [0..29, 0..4] de réel

Ici, NotesClasse peut contenir 30 * 5 = 150 notes.

Pour voir une autre présentation de cette syntaxe, vous pouvez consulter le document suivant.

[PDF] Chapitre 5:Les tableaux et les chaines de caractères

Le document '[PDF] Chapitre 5: Les tableaux et les chaines de caractères' présente également la déclaration des tableaux 2D.

Consultez les diapositives 23 et 24. La diapositive 23 ('Tableau á deux dimensions (2D)') définit la structure. La diapositive 24 ('Déclaration...') montre la syntaxe en pseudo-code ('algorithmique'). Notez que ce document utilise une indexation qui commence à 1 (1..tailleL). Dans nos leçons, nous privilégierons l'indexation à partir de 0, car c'est la convention dans la plupart des langages de programmation, y compris Java.

3. Accéder et manipuler les éléments

C'est le cœur de la leçon. Pour accéder à un élément spécifique (une "case" de la grille), il faut fournir ses deux coordonnées : son indice de ligne et son indice de colonne. La convention est toujours [ligne, colonne].

Reprenons notre matrice NotesClasse[0..29, 0..4].

  • NotesClasse[0, 2] fait référence à la note du premier étudiant (ligne 0) dans la troisième matière (colonne 2).
  • NotesClasse[15, 0] fait référence à la note du 16ème étudiant (ligne 15) dans la première matière (colonne 0).

L'image suivante illustre parfaitement cet accès par coordonnées.

Exemple de tableau à deux dimensions avec indexation
Cette image montre une matrice `T`. Pour accéder à la valeur `2`, on utilise les coordonnées `T[1, 4]` (ligne 1, colonne 4). De même, `T[3, 4]` pointe vers la valeur `9`. Notez que cet exemple utilise une indexation à partir de 1.

Une fois que nous avons accédé à une case, nous pouvons lire sa valeur ou lui en assigner une nouvelle, comme avec une variable simple.

Exemple de manipulation :

Supposons que nous avons une grille de Morpion (Tic-Tac-Toe) de 3x3. On la déclare ainsi :
Var GrilleMorpion : tableau [0..2, 0..2] de caractère

Initialement, on pourrait la remplir avec des espaces. Pour que le joueur 'X' joue au centre, on écrirait :
GrilleMorpion[1, 1] ← 'X'

Pour que le joueur 'O' joue dans le coin supérieur gauche :
GrilleMorpion[0, 0] ← 'O'

4. Un premier pas vers le traitement : Somme d'une ligne

Comment peut-on utiliser cet accès pour effectuer des calculs ? Imaginons que nous voulions calculer la somme des éléments d'une seule ligne de la matrice. Pour cela, la ligne est fixe, et nous allons parcourir toutes les colonnes de cette ligne avec une boucle Pour.

L'image ci-dessous illustre ce processus : pour faire la somme de la ligne 2, on garde l'indice de ligne i fixé à 2, et on fait varier l'indice de colonne j de 1 à 5.

Example: Sum of a Row in a 2D Array
À gauche, une matrice `M` où la ligne 2 (avec les valeurs 3, 1, 2, 4, 3) est surlignée. À droite, l'algorithme en pseudo-code qui calcule la somme `S` des éléments de cette ligne spécifique en utilisant une boucle sur les colonnes `j`.

Voici l'algorithme correspondant à cette image, adapté avec notre indexation à partir de 0. Supposons que la ligne à sommer soit L=1 (la deuxième ligne).

Algorithme SommeLigne
  Var
    M : tableau [0..2, 0..4] de entier // Notre matrice 3x5
    S : entier // Pour stocker la somme
    j : entier // Indice pour les colonnes

  Début
    // (Ici, on supposerait que la matrice M a déjà été remplie)

    S ← 0
    // On parcourt toutes les colonnes de la ligne L=1
    Pour j de 0 à 4 faire
      S ← S + M[1, j] // On ajoute l'élément de la ligne 1, colonne j
    FinPour

    Ecrire("La somme de la deuxième ligne est : ", S)
  Fin

Ce type d'opération, où l'on parcourt une partie d'une matrice, est extrêmement courant.

5. Exercice pratique

Pour mettre en application ce que vous venez d'apprendre, voici un petit exercice.

Énoncé :
Vous êtes en train de concevoir un mini-programme pour gérer les places d'une petite salle de cinéma. La salle a 5 rangées et 8 sièges par rangée.

  1. Écrivez la déclaration en pseudo-code d'une matrice nommée SalleCinema pour représenter les sièges. Un siège libre sera représenté par le booléen VRAI et un siège occupé par FAUX.
  2. Écrivez les instructions pour assigner des valeurs initiales :
    • Au début, tous les sièges sont libres. Vous n'avez pas besoin d'écrire la boucle pour cela, imaginez simplement que c'est fait.
  3. Maintenant, écrivez les instructions spécifiques pour marquer comme occupés les sièges suivants :
    • Le siège au centre exact de la salle (si les dimensions sont paires, choisissez l'un des sièges centraux).
    • Le tout premier siège (première rangée, premier siège).
    • Le tout dernier siège (dernière rangée, dernier siège).

Prenez quelques minutes pour écrire votre solution, puis comparez-la avec la proposition ci-dessous.

Cliquez ici pour voir la solution 
Algorithme GestionCinema
  Var
    // 1. Déclaration de la matrice 5x8
    // Les rangées sont indexées de 0 à 4.
    // Les sièges sont indexés de 0 à 7.
    SalleCinema : tableau [0..4, 0..7] de booléen

  Début
    // 2. On suppose que tous les sièges sont initialisés à VRAI (libre).

    // 3. Marquer des sièges comme occupés (FAUX).

    // Le siège au centre (ex: rangée 2, siège 3)
    // Ligne 2 est la 3ème rangée, Siège 3 est le 4ème siège.
    SalleCinema[2, 3] ← FAUX

    // Le tout premier siège
    SalleCinema[0, 0] ← FAUX

    // Le tout dernier siège
    SalleCinema[4, 7] ← FAUX

    // On pourrait ensuite afficher l'état d'un siège pour vérifier :
    Ecrire("État du siège [2, 3] (doit être FAUX): ", SalleCinema[2, 3])
    Ecrire("État du siège [0, 0] (doit être FAUX): ", SalleCinema[0, 0])
    Ecrire("État du siège [4, 7] (doit être FAUX): ", SalleCinema[4, 7])
  Fin

Conclusion

Félicitations ! Vous avez fait vos premiers pas avec les tableaux à deux dimensions. C'est une structure de données fondamentale en programmation.

Les points clés à retenir :

  • Un tableau à deux dimensions (ou matrice) organise les données en lignes et colonnes.
  • On le déclare en spécifiant les deux dimensions : tableau [nb_lignes, nb_colonnes].
  • L'accès à un élément se fait via deux indices : NomTableau[indice_ligne, indice_colonne].
  • Cette structure est idéale pour modéliser des grilles, des tables, des plateaux de jeu, des images, etc.

Et après ?

Nous savons maintenant déclarer une matrice et accéder à n'importe quelle case individuellement. Mais la vraie puissance des matrices se révèle lorsqu'on les traite dans leur intégralité. Dans la prochaine leçon, nous apprendrons à parcourir une matrice entière à l'aide de boucles imbriquées. Cela nous ouvrira la porte à des opérations plus complexes comme la somme de deux matrices ou la recherche d'un élément dans toute la grille.