Tri par ordre décroissant efficace des tableaux avec C#

Le tri des tableaux est une opération fondamentale en programmation. C# offre plusieurs manières efficaces de trier les tableaux, y compris dans l’ordre décroissant. Cet article explore deux approches principales : l’utilisation de Array.Sort() et Array.Reverse(), et l’utilisation de la méthode OrderByDescending() de LINQ.

Table des matières

• Tri avec Array.Sort() et Array.Reverse()
• Tri avec OrderByDescending()

Tri avec Array.Sort() et Array.Reverse()

La méthode Array.Sort(), par défaut, trie un tableau par ordre croissant. Pour obtenir un ordre décroissant, on trie d’abord par ordre croissant, puis on inverse le tableau à l’aide de Array.Reverse(). Ceci est efficace pour les types de données simples comme les entiers ou les chaînes de caractères.

using System;

public class SortArrayDescending
{
    public static void Main(string[] args)
    {
        int[] numbers = { 5, 2, 8, 1, 9, 4 };

        Array.Sort(numbers); // Tri par ordre croissant
        Array.Reverse(numbers); // Inversion pour l'ordre décroissant

        Console.WriteLine("Tableau trié par ordre décroissant :");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        // Sortie : 9 8 5 4 2 1
    }
}

Ceci démontre de manière concise la technique. Le tri initial croissant suivi de l’inversion fournit l’ordre décroissant souhaité.

Tri avec OrderByDescending()

Pour des scénarios plus complexes, notamment lorsque l’on travaille avec des objets personnalisés ou que l’on a besoin de critères de tri plus sophistiqués, la méthode OrderByDescending() de LINQ offre une plus grande flexibilité. Cette méthode utilise des expressions lambda pour définir la logique de tri.

using System;
using System.Linq;

public class SortArrayDescendingLinq
{
    public static void Main(string[] args)
    {
        int[] numbers = { 5, 2, 8, 1, 9, 4 };

        var sortedNumbers = numbers.OrderByDescending(x => x).ToArray();

        Console.WriteLine("Tableau trié par ordre décroissant :");
        foreach (int number in sortedNumbers)
        {
            Console.Write(number + " ");
        }
        // Sortie : 9 8 5 4 2 1


        // Exemple avec des objets personnalisés
        var people = new[]
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 25 },
            new Person { Name = "Charlie", Age = 35 }
        };

        var sortedPeopleByAge = people.OrderByDescending(p => p.Age).ToArray();

        Console.WriteLine("nPersonnes triées par âge par ordre décroissant :");
        foreach (var person in sortedPeopleByAge)
        {
            Console.WriteLine($"{person.Name} : {person.Age}");
        }
        // Sortie : Charlie : 35, Alice : 30, Bob : 25
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

L’exemple montre le tri d’un tableau d’entiers et d’un tableau d’objets Person personnalisés par âge. Notez que OrderByDescending() retourne un IOrderedEnumerable<T>, nécessitant une conversion en tableau à l’aide de ToArray(). Cette approche est très lisible et adaptable à divers besoins de tri, bien qu’elle puisse introduire un peu plus de surcharge que la première méthode pour les types de données simples.

Le choix entre ces méthodes dépend de vos besoins spécifiques et de la complexité des données. Pour les types de données simples, Array.Sort() et Array.Reverse() offrent l’efficacité. Pour les objets complexes et les critères de tri flexibles, OrderByDescending() offre une solution plus puissante et plus lisible.