C# - Sort Arrays

Sorting an Array in C# 

The Array.Sort method is the simplest way to sort an array in ascending order.

Example

int[] numbers = { 5, 2, 8, 1, 3 };

// Sort in ascending order
Array.Sort(numbers);

// Print sorted array
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

Sorting in Descending Order

Use the Array.Reverse method after sorting to get the array in descending order.

int[] numbers = { 5, 2, 8, 1, 3 };

// Sort in ascending order
Array.Sort(numbers);

// Reverse the sorted array
Array.Reverse(numbers);

// Print sorted array
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

Sorting Arrays of Objects

To sort an array of objects, you can use a custom comparison or IComparable.

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }

    public Employee(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

class Program
{
    static void Main()
    {
        Employee[] employees = {
            new Employee(3, "John"),
            new Employee(1, "Alice"),
            new Employee(2, "Bob")
        };

        // Sort by Id
        Array.Sort(employees, (x, y) => x.Id.CompareTo(y.Id));

        // Print sorted array
        foreach (var employee in employees)
        {
            Console.WriteLine($"Id: {employee.Id}, Name: {employee.Name}");
        }
    }
}

Result

Id: 1, Name: Alice
Id: 2, Name: Bob
Id: 3, Name: John

 Sorting Using LINQ

LINQ provides an elegant way to sort arrays using OrderBy and OrderByDescending.

int[] numbers = { 5, 2, 8, 1, 3 };

// Sort in ascending order
var sortedNumbers = numbers.OrderBy(n => n).ToArray();

// Sort in descending order
var sortedDescending = numbers.OrderByDescending(n => n).ToArray();

// Print results
Console.WriteLine("Ascending: " + string.Join(", ", sortedNumbers));
Console.WriteLine("Descending: " + string.Join(", ", sortedDescending));

Result

Ascending: 1, 2, 3, 5, 8
Descending: 8, 5, 3, 2, 1

Custom Sorting with Comparers

You can implement a custom comparer by inheriting from IComparer.

public class DescendingComparer : IComparer<int>
{
    public int Compare(int x, int y)
    {
        return y.CompareTo(x); // Reverse comparison for descending order
    }
}

class Program
{
    static void Main()
    {
        int[] numbers = { 5, 2, 8, 1, 3 };

        // Sort using custom comparer
        Array.Sort(numbers, new DescendingComparer());

        // Print sorted array
        foreach (var number in numbers)
        {
            Console.WriteLine(number);
        }
    }
}

Result

8
5
3
2
1

Performance Considerations

• Array.Sort: Uses an optimized QuickSort for smaller arrays and HeapSort for larger ones.
• LINQ: May introduce slight overhead due to deferred execution and creation of new collections.
• Custom Comparers: Allow flexible sorting but can slow down sorting due to additional logic.