1. Tableaux à une dimension

1.1. Comment

1.1.1. Forme

Un tableau est un type de données. Une variable de ce type « contiendra » en quelque sorte :

• plusieurs variables, disons n (n sera la longueur du tableau),
• d’un même type, disons T.

Les n variables sont rangées de façon linéaire (en ligne) et repérées par un nombre entier compris entre :

• 0 et n-1 dans la plupart des cas,
• 1 et n dans certains langages,
• encore autrement dans les autres langages.

Ce nombre est appelé l’index ou l’indice et est mis la plupart du temps entre crochets après le nom de la variable de type tableau.

Ici, on a représenté une variable tab de type tableau. Les tab[i] sont tous de type T.

Les autres noms des tableaux sont : vecteur, vector, array…

1.1.2. Contraintes

On rappelle que les éléments d’un même tableau sont d’un même type.

De plus, la longueur du tableau est fixe. Une fois créé, un tableau ne peut pas changer pas de taille.

1.2. Pourquoi

Un tableau sert à stocker une série de valeurs. Parmi les types de valeurs les plus fréquemment rencontrés, on trouve :

• des nombres (entiers ou flottants),
• des caractères (dans certains langages, un tel tableau formera une chaîne de caractères, et en Python, une chaîne de caractère est une liste de caractères),
• des tableaux (voir plus loin), ce qui permet d’obtenir une structure où les éléments sont repérés par deux coordonnées.

1.3. Syntaxes

1.3.1. Pseudo-code

Variables
 |  tableau d’entiers de longueur 3: mon_tab
 |  // ou Entiers[]: mon_tab
 |  // ou Entiers[3]: mon_tab
Début
 |  // pas besoin de construction
 |  // initialisation ou affectation
 |  mon_tab[0] = 666
 |  // lecture (ici pour affichage)
 |  Afficher mon_tab[0]
 |  // saisie utilisateur
 |  Demander mon_tab[1]
Fin

1.3.2. Python

Python n’a pas de tableaux, mais il est possible de les simuler. Voir le module tableaux, et surtout ses doctests.

1.3.3. C sharp

// déclaration
T[] mon_tab;
// construction
mon_tab = new T[n];
// les deux en même temps
T[] mon_tab = new T[n];

L’accès en lecture et écriture se fait pour chaque case comme s’il s’agissait d’une simple variable, mais avec les crochets.

1.4. Parcours d’un tableau

Le principe est de « boucler sur les indices ». Puisqu’on connaît la longueur du tableau, on utilise le plus souvent une boucle POUR.

1.4.0.1. Pseudo-code

Un exemple avec une fonction somme :

Fonction somme(Entiers[]: tab): Entier
 |  Entier s
 |  s <- 0
 |  Pour i de 0 à longueur(tab) - 1
 |   |  s <- s + tab[i]
 |  Fin Pour
 |  Retourne s
Fin Fonction

1.4.0.2. Python

Il n’y a pas de boucle POUR en Python (for dans les autres langages), mais plutôt une boucle POUR CHAQUE (souvent notée foreach dans les autres langages). Il faut taper :

for element in une_liste:
    # traitement

À noter :

• les deux points habituels qui ouvrent un bloc de code,
• element est la variable qui va prendre, tour après tour, les valeurs stockées dans une_liste, dans l’ordre,
• on utilise très souvent range pour générer un ensemble de nombres adéquats, ce qui permettra finalement de récupérer une boucle POUR classique.

>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0, 10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(10, step=2))
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    list(range(10, step=2))
TypeError: range() does not take keyword arguments
>>> list(range(10, 2))
[]

Voir la documentation de range.

>>> for i in range(3):
...     print("itération numéro:", i)
... 
itération numéro: 0
itération numéro: 1
itération numéro: 2

>>> liste = [42, "manger", 3.14]
>>> for i in range(len(liste)):
...     print(liste[i])
... 
42
manger
3.14

>>> for elt in liste:
...     print(elt)
... 
42
manger
3.14

>>> for i in range(len(liste)):
...     print("Élement n°", i, "=", liste[i])
... 
Élement n° 0 = 42
Élement n° 1 = manger
Élement n° 2 = 3.14

>>> for i, elt in enumerate(liste):
...     print("Élement n°", i, "=", elt)
... 
Élement n° 0 = 42
Élement n° 1 = manger
Élement n° 2 = 3.14

>>> list(range(3, 0, -1))
[3, 2, 1]
>>> list(range(3, -1, -1))
[3, 2, 1, 0]
>>> list(range(2, -1, -1))
[2, 1, 0]
>>> def retrorange(n):
...     return range(n-1, -1, -1)
...
>>> list(antirange(3))
[2, 1, 0]

2. Tableaux de dimension 2

2.1. Pourquoi et comment

2.1.1. Principe

On considère un tableau tab de longueur m, dans lequel chaque élément est à nouveau un tableau, mais de longueur n.

2.1.2. Remarques

• Un tableau de tableaux est une structure de données de dimension 2.
• i peut être considéré comme les abscisses, j comme les ordonnées.
• Une telle structure contient m×n éléments.
• On peut ainsi modéliser les pixels d’un écran, mais surtout les matrices.
• Les autres noms des tableaux de dimension 2 sont : matrice, matrix…
• Un tableau de longueur m contenant des tableaux de longueur n contenant à leur tour des tableaux de longueur p est une structure à trois dimensions contenant m×n×p éléments.

2.2. Syntaxe

2.2.1. Pseudo-code

// déclarations
Tableau d’Entiers (m×n): tab
Entiers[m][n]: tab
Entiers[][]: tab
// accès aux tableaux en lecture ou écriture
tab[i][j]  // voir le diagramme ci-dessus

2.2.2. Python

# «initialisation» (que des None)
tab = Tableau(m)
tab[0] = Tableau(n)
tab[1] = Tableau(n)
...
tab[m-1] = Tableau(n)
# accès aux tableaux en lecture ou écriture
tab[i][j]  // voir le diagramme ci-dessus

2.2.3. C Sharp

On n’utilise pas tab[i][j], mais tab[i,j].

2.3. Parcours

Le principe est de « boucler sur les indices ». Puisqu’on connaît les longueurs des tableaux, on utilise des boucles POUR. Mais leur agencement doit être très spécial : elles doivent être imbriquées.

La première boucle, dite « externe » va parcourir le tableau qui contient les autres tableaux, afin de « choisir » un des sous-tableaux. La deuxième boucle, dite « interne » va parcourir le tableau ainsi « choisi » pour y choisir un élément.

Le fichier est disponible ici.

Remarques :

• La boucle interne « tourne » plus vite.
• C’est la manière canonique (naturelle) de parcourir un tableau de tableaux, mais il y en a d’autres (voir les exercices).

+-----+-----+
|     |     |
+-----+-----+
 +---+ +---+
 | 1 | | 4 |
 +---+ +---+
 | 2 | | 5 |
 +---+ +---+
 | 3 | | 6 |
 +---+ +---+

Aller aux exercices