En informatiques un tableau est un regroupement de variables de même type mises dans des cases contigües en mémoire centrale. Voici un exemple de tableau de 4 notes en mémoire centrale :

En programmation, un nom est donné au tableau et on utilise un indice plutôt que les adresses mémoire :

Le tableau notes :

Pour accéder à une variable du tableau, il faut :

• utiliser le nom du tableau ;
• suivi d'un indice de case.

Un tableau statique a une taille fixe déterminée à la déclaration du tableau.

Un tableau dynamique a une taille qui est définie lors de l'exécution du programme. La taille du tableau est alors définie au moment de l’exécution du programme et en fonction du déroulement de ce programme. Cela permet d'avoir une allocation dynamique de mémoire en fonction des besoins.

Pour déclarer un tableau en C# il faut que

• le nombre de case soit fixe ;
• et définir dès le départ le nombre de cases ;
• précisez le type des données.

letype[] nomTableau = new letype[taille];
// exemple
int[] notes = new int[4];

Un tableau s’utilise comme une variable mais en précisant l’indice de la case concernée.

// exemple
notes[0] = 10;
notes[1] = 9;
notes[2] = 15;
notes[3] = 12;

Voici une manière de renseigner le tableau de notes avec les valeurs saisies par l'utilisateur :

// Déclaration du tableau
int[] notes = new int[4];
 
// Saisie des notes
for (int i = 0; i < 4; i++)
{
  Console.Write("Entrez une note  : ");
  notes[i] = int.Parse(Console.ReadLine());
}

Pour initialiser un tableau lors de sa déclaration, procédez de la manière suivante :

int[] monTableau = new int[] {1, 2, 3, 4, 5};

Un tableau dynamque en C# est une liste de données qui peut changer de taille pendant l’exécution du programme.

Une liste est une collection ordonnée d’éléments. Chaque élément a un index, et il est possible d'ajouter, d'insérer, de supprimer et de trouver des éléments à n’importe quel endroit dans la liste.

Pour utiliser les listes en C#, il faut inclure le namespace en haut de ton fichier

using System.Collections.Generic;

La déclaration d’une liste en C# est similaire à celle d’un tableau, mais elle utilise la classe List<T>, où T est le type de données que la liste va stocker.

List<int> maListe = new List<int>();

Dans cet exemple, <int> est le type de la liste, maListe est le nom de la liste, et new List<int>() est l’instance de la liste.

Il n'est pas nécessaire de spécifier une taille lors de la déclaration d’une liste car les sont dynamiques et peuvent changer de taille.

Par défaut, une liste nouvellement créée ne contient aucun élément.

Pour déclarer et et initialiser une liste en même temps, tout comme un tableau :

List<int> maListe = new List<int> {1, 2, 3, 4, 5};

La méthode Add() est utilisée pour ajouter un élément à la fin de la liste.

List<int> maListe = new List<int>(); // créer une nouvelle liste vide
maListe.Add(1); // ajouter 1 à la liste
maListe.Add(2); // ajouter 2 à la liste

La méthode AddRange() prend une collection d’éléments et les ajoute à la fin de la liste.

List<int> maListe = new List<int>(); // créer une nouvelle liste vide
maListe.AddRange(new int[] {1, 2, 3, 4, 5}); // ajouter plusieurs éléments à la liste

Après cette instruction, maListe contient les valeurs {1, 2, 3, 4, 5}.

Pour insérer un élément à une position spécifique de la liste, plutôt qu’à la fin, on utilise la méthode Insert() qui prend deux paramètres :

• l’index à laquelle l’élément doit être inséré
• et l’élément à insérer :

List<int> maListe = new List<int>() {1, 2, 3, 4, 5}; // créer et initialiser une liste
maListe.Insert(2, 10); // insérer 10 à l’index 2

La méthode Remove() permet de supprimer des éléments d'une liste.

Il est parfois nécessaire de trier les tableaux ou de faire des recherches dans les tableaux.

Pour information, voici les vidéos sur 3 solutions possible de tris, en C# :

• Tri par sélection : https://youtu.be/0Z8rYUjFrG4
• Tri par insertion : https://youtu.be/dSN7mtGOeZc
• Tri par bulle : https://youtu.be/kUP8kb9t50Q

La recherche se fait

• à partir de la première case du tableau,
• en comparant chaque case avec la valeur cherchée,
• et la recherche s’arrête dès que la valeur est trouvée, ou en fin de tableau si la valeur n’est pas présente.

C’est la méthode de recherche la plus simple et qui fonctionne que le tableau soit trié ou non. Cependant, cette méthode est peu performante dans le cas d’un tableau trié.

Le nombre d’itérations n’est pas fixe.

• au minimum : 1 fois (si la valeur se trouve dans la 1re case)
• au maximum : n fois (si la valeur n’est pas trouvée)

• Les tableaux qui ont été présentés étaient à une dimension.
• Il est possible de déclarer des tableaux à plusieurs dimensions.
• Les tableaux à 2 dimensions peuvent aussi être appelés matrices.

// Syntaxe de la déclaration
letype[,] nomTableau = new letype[nbColonnes,nbLignes];
 
// Syntaxe d’accès à une case
nomTableau[indiceColonne, indiceLigne]
 
// Exemple de déclaration
int[,] distance = new int[10,20];
 
/* Affichage de la case d’indices (i, j)
* avec i forcément entre 0 et 9
* avec j forcément entre 0 et 19 */
Console.WriteLine(distance[i, j]);
 
// boucles pour remplir chaque case de la matrice
for (int x = 0; x < 10; x++)
{
  for (int y = 0; y < 20; y++)
  {
    distance[x, y] = int.Parse(Console.ReadLine());
  }
}