Opérations de base sur les tableaux unidimensionnels

1. Introduction

Qu’est-ce qu’on veut souvent faire avec les tableaux ?

Faisons la liste des opérations de base :

• Lire et modifier les éléments du tableau par index.
• Chercher un élément par valeur.
• Copier un tableau, créer des “tranches” (une partie du tableau).
• Trier un tableau.
• Inverser (reverse) un tableau.
• Remplir un tableau avec une valeur.
• Vérifier la présence d’un élément (est-ce que le tableau contient une valeur donnée ?).
• Changer la longueur (resize).

Dans la vraie vie, tu vas souvent faire ce genre de trucs — genre « y a-t-il une somme supérieure à 4000 ? », « trouve le premier prix en dessous de 1000 », « trie les prix par ordre croissant », etc.

Et pour tout ça, on a des fonctions

arr[n] = x

Array.IndexOf(arr, v)

Array.Exists(arr, pred)

Array.Sort(arr)

Array.Reverse(arr)

arr.Clone(), Array.Copy

Array.Fill(arr, val)

Array.Resize(ref arr, len)

arr.Max(), arr.Min()

2. Lire et modifier des éléments par index

On connaît déjà ça, mais on va revoir avec un exemple simple (imaginons qu’on a un tableau de notes) :

// Tableau des notes d’un étudiant
int[] grades = { 4, 3, 5, 2, 5 };

// Lire la première note
int firstGrade = grades[0];
Console.WriteLine($"Première note : {firstGrade}");

// Modifier la dernière note en "excellent" (5)
grades[^1] = 5;
Console.WriteLine("Dernière note modifiée : " + grades[^1]);

Ce qui est important ici : l’indexation commence à zéro, et si tu essaies d’accéder à un index qui n’existe pas, tu auras une erreur IndexOutOfRangeException — un classique en entretien et dans la vraie vie.

3. Chercher un élément dans un tableau

On a deux fonctions pour chercher un élément dans un tableau, et elles renvoient son index si elles le trouvent.

Fonction Array.IndexOf(value [, from])

La fonction Array.IndexOf cherche l’élément donné depuis le début du tableau. Si elle le trouve, elle renvoie son index. Sinon — elle renvoie -1.

Mais si tu veux trouver les occurrences suivantes de l’élément dans le tableau ? Pour ça, il faut passer un deuxième paramètre à Array.IndexOf — l’index à partir duquel elle commence à chercher. Ça doit être l’index du dernier élément trouvé + 1.

Allons trouver toutes les occurrences du nombre 2 dans notre tableau :

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // l’élément qu’on cherche

int index = Array.IndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Élément {x} trouvé à la position : {index}");
    // Cherche l’index suivant, à partir de index + 1
    index = Array.IndexOf(grades, x, index + 1);
} 

Fonction Array.LastIndexOf(value [, from])

La fonction Array.LastIndexOf cherche l’élément donné à partir de la fin du tableau. Si elle le trouve, elle renvoie son index. Sinon — elle renvoie -1. Sinon, c’est pareil que Array.IndexOf.

Allons trouver toutes les occurrences du nombre 2 dans notre tableau, mais cette fois en cherchant depuis la fin :

int[] grades = { 4, 3, 5, 2, 5, 2 };
int x = 2; // l’élément qu’on cherche

int index = Array.LastIndexOf(grades, x);
while (index != -1)
{
    Console.WriteLine($"Élément {x} trouvé à la position : {index}");
    // Cherche l’index suivant, à partir de la position précédente - 1
    index = Array.LastIndexOf(grades, x, index - 1);
}

4. Vérifier la présence d’un élément dans un tableau

Pour vérifier la présence d’un élément, il y a la fonction Contains. Cette méthode renvoie true si le tableau contient l’élément donné. Pour l’utiliser, il faut absolument ajouter le module System.Linq. Exemple :

using System.Linq; // Ajoute using System.Linq; si ce n’est pas déjà fait

bool hasExcellent = grades.Contains(5); 
Console.WriteLine($"Y a-t-il un cinq ? {hasExcellent}");

C’est super simple et propre.

5. Inverser un tableau : Array.Reverse

Imaginons que tu veux retourner un tableau “à l’envers”. Utilise :

int[] grades = { 2, 3, 4, 5 };

// On inverse le tableau
Array.Reverse(grades);
Console.WriteLine("Notes inversées : " + string.Join(", ", grades));

C’est super pratique pour chercher les “données les plus récentes” ou juste si tu veux voir le monde à l’envers.

6. Trier un tableau : Array.Sort

Tôt ou tard, tu voudras trier un tableau. Le moyen le plus court et sûr — c’est d’utiliser la fonction de tri standard :

int[] grades = { 4, 3, 5, 2, 5 };
// Tri par ordre croissant
Array.Sort(grades);
Console.WriteLine("Notes triées : " + string.Join(", ", grades));

Cette fonction trie aussi les chaînes, mais par ordre alphabétique.

Tri décroissant

Le Array.Sort standard trie seulement par ordre croissant. Pour trier par ordre décroissant, tu peux faire un tri + reverse :

Array.Sort(grades); // D’abord croissant
Array.Reverse(grades); // Puis on inverse
Console.WriteLine("Décroissant : " + string.Join(", ", grades));

Remarque : on oublie souvent que le tri se fait “sur place” : le tableau est modifié, il n’y a pas de retour d’un nouveau tableau. Si tu veux garder l’ordre d’origine, copie d’abord le tableau original.

7. Cloner un tableau : Clone et Array.Copy

Si tu veux faire une copie (et ne pas casser le tableau original pendant le traitement), utilise les méthodes Clone() et Array.Copy().

La méthode Clone() doit être appelée sur le tableau, et elle renvoie une copie complète.

La méthode Array.Copy() demande qu’on lui passe :

• le tableau source ;
• le tableau où copier les données ;
• combien de cases à copier.

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

// Méthode 1 : Clone()
// Marche pour les tableaux 1D et multiD, mais retourne un object, il faut un cast :
int[] copy1 = (int[]) original.Clone();

// Méthode 2 : Array.Copy
int[] copy2 = new int[original.Length];
Array.Copy(original, copy2, original.Length);

Point important : les tableaux sont copiés par valeur si c’est des types primitifs (int, double). Si c’est un tableau d’objets, seules les références sont copiées ! (c’est ce qu’on appelle une “copie superficielle”).

8. Remplir un tableau avec une valeur : Array.Fill

Tu veux “remettre à zéro” un tableau ou le remplir de cinq partout ? Pour ça, il y a la méthode pratique — Array.Fill :

int[] grades = new int[5];
Array.Fill(grades, 5); // Maintenant tous les éléments valent 5
Console.WriteLine("Étudiant hypothétiquement parfait : " + string.Join(", ", grades));

Utile quand tu veux initialiser rapidement un tableau avec une valeur donnée.

9. Chercher la valeur maximale et minimale

Le module System.Linq a ajouté plein de méthodes utiles aux tableaux, et deux d’entre elles renvoient la valeur minimale et maximale dans un tableau. Elles s’appellent Max() et Min().

Allons chercher la note maximale ou minimale dans un tableau :

int maxGrade = grades.Max();
int minGrade = grades.Min();
Console.WriteLine($"Note maximale : {maxGrade}, minimale : {minGrade}");

N’oublie pas d’ajouter using System.Linq; pour ces méthodes.

2

Mission

C# SELF, niveau 7, leçon 3

Bloqué

Tri d'un tableau et recherche de l'élément maximal

Tri d'un tableau et recherche de l'élément maximal

Ouvrir

2

Mission

C# SELF, niveau 7, leçon 3

Bloqué

Recherche de toutes les occurrences d'un élément dans un tableau

Recherche de toutes les occurrences d'un élément dans un tableau

Ouvrir