Ordenación eficiente de arrays en orden descendente con C#

Ordenar matrices es una operación fundamental en programación. C# ofrece varias maneras eficientes de ordenar matrices, incluyendo el orden descendente. Este artículo explora dos enfoques principales: aprovechar Array.Sort() y Array.Reverse(), y utilizar el método OrderByDescending() de LINQ.

Tabla de contenido

• Ordenar con Array.Sort() y Array.Reverse()
• Ordenar con OrderByDescending()

Ordenar con Array.Sort() y Array.Reverse()

El método Array.Sort(), por defecto, ordena una matriz en orden ascendente. Para lograr el orden descendente, primero ordenamos en orden ascendente y luego invertimos la matriz usando Array.Reverse(). Esto es eficiente para tipos de datos simples como enteros o cadenas.

using System;

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

        Array.Sort(numbers); // Ordenar en orden ascendente
        Array.Reverse(numbers); // Invertir para orden descendente

        Console.WriteLine("Matriz ordenada en orden descendente:");
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        // Salida: 9 8 5 4 2 1
    }
}

Esto demuestra concisamente la técnica. La ordenación ascendente inicial seguida de la inversión proporciona el orden descendente deseado.

Ordenar con OrderByDescending()

Para escenarios más complejos, especialmente cuando se trabaja con objetos personalizados o se requieren criterios de ordenación más sofisticados, el método OrderByDescending() de LINQ ofrece mayor flexibilidad. Este método emplea expresiones lambda para definir la lógica de ordenación.

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("Matriz ordenada en orden descendente:");
        foreach (int number in sortedNumbers)
        {
            Console.Write(number + " ");
        }
        // Salida: 9 8 5 4 2 1


        // Ejemplo con objetos personalizados
        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("nPersonas ordenadas por edad en orden descendente:");
        foreach (var person in sortedPeopleByAge)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
        // Salida: Charlie: 35, Alice: 30, Bob: 25
    }

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

El ejemplo muestra la ordenación de una matriz de enteros y una matriz de objetos Person personalizados por edad. Tenga en cuenta que OrderByDescending() devuelve un IOrderedEnumerable<T>, que requiere conversión a una matriz usando ToArray(). Este enfoque es altamente legible y adaptable a diversas necesidades de ordenación, aunque podría introducir una sobrecarga ligeramente mayor que el primer método para tipos de datos simples.

La elección entre estos métodos depende de sus necesidades específicas y la complejidad de los datos. Para tipos de datos simples, Array.Sort() y Array.Reverse() ofrecen eficiencia. Para objetos complejos y criterios de ordenación flexibles, OrderByDescending() proporciona una solución más potente y legible.