How to Sort Arrays in C# Without LINQ

Sorting arrays is a common task in programming, and in C#, you can sort arrays without relying on LINQ. This article explores different techniques for sorting arrays in C#, focusing on built-in methods and manual implementations of sorting algorithms.

Why Sort Arrays Without LINQ?

Although LINQ provides easy sorting with methods like OrderBy, it’s useful to understand alternative sorting approaches, especially when working in environments where LINQ might not be available, or for performance reasons.

---

1. Using the Array.Sort Method

The simplest way to sort arrays in C# without LINQ is by using the Array.Sort method. This built-in method sorts an array in place, modifying the original array.

Example

using System;

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

Array.Sort(numbers);

Console.WriteLine("Sorted array: ");
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

Sorted array:
1
2
3
5
8

Explanation

The Array.Sort method uses a modified quicksort algorithm for sorting primitive types, providing efficient performance for most use cases.

---

2. Sorting Arrays in Descending Order with Array.Sort and Array.Reverse

The Array.Sort method sorts arrays in ascending order by default. To sort in descending order, you can call Array.Sort followed by Array.Reverse.

Example

using System;

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

Array.Sort(numbers);
Array.Reverse(numbers);

Console.WriteLine("Sorted array in descending order: ");
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

Sorted array in descending order:
8
5
3
2
1

Explanation

Using Array.Reverse after sorting the array in ascending order is a simple way to get descending order without implementing custom logic.

---

3. Implementing Bubble Sort

Bubble Sort is a straightforward sorting algorithm where each pair of adjacent elements is compared, and the elements are swapped if they are out of order. It’s easy to implement, though it’s not as efficient as other sorting algorithms for large arrays.

Example

using System;

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

for (int i = 0; i < numbers.Length - 1; i++)
{
    for (int j = 0; j < numbers.Length - i - 1; j++)
    {
        if (numbers[j] > numbers[j + 1])
        {
            int temp = numbers[j];
            numbers[j] = numbers[j + 1];
            numbers[j + 1] = temp;
        }
    }
}

Console.WriteLine("Bubble-sorted array: ");
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

Bubble-sorted array:
1
2
3
5
8

Explanation

Bubble Sort is not the most efficient for large datasets, but it provides a step-by-step introduction to sorting logic. For smaller arrays or for learning purposes, it’s an excellent way to understand sorting mechanics.

---

4. Implementing Selection Sort

Selection Sort works by repeatedly finding the minimum element from the unsorted part of the array and placing it at the beginning. It’s more efficient than Bubble Sort but still less optimal for larger arrays.

Example

using System;

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

for (int i = 0; i < numbers.Length - 1; i++)
{
    int minIndex = i;
    for (int j = i + 1; j < numbers.Length; j++)
    {
        if (numbers[j] < numbers[minIndex])
        {
            minIndex = j;
        }
    }

    int temp = numbers[minIndex];
    numbers[minIndex] = numbers[i];
    numbers[i] = temp;
}

Console.WriteLine("Selection-sorted array: ");
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

Selection-sorted array:
1
2
3
5
8

Explanation

Selection Sort is a bit more efficient than Bubble Sort, especially for arrays with fewer elements. It reduces the number of swaps compared to Bubble Sort, making it a bit faster in practice.

---

5. Implementing Insertion Sort

Insertion Sort is another simple sorting algorithm, suitable for smaller or nearly sorted arrays. It builds the sorted array one element at a time by repeatedly inserting the next element into its proper position.

Example

using System;

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

for (int i = 1; i < numbers.Length; i++)
{
    int key = numbers[i];
    int j = i - 1;

    while (j >= 0 && numbers[j] > key)
    {
        numbers[j + 1] = numbers[j];
        j--;
    }
    numbers[j + 1] = key;
}

Console.WriteLine("Insertion-sorted array: ");
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

Output

Insertion-sorted array:
1
2
3
5
8

Explanation

Insertion Sort is efficient for smaller datasets and nearly sorted arrays. It’s also beneficial in real-time applications where only small portions of data need sorting frequently.

---

Choosing the Right Sorting Method

Sorting Method	Complexity	Use Case
Array.Sort	O(n log n)	General-purpose, quick and easy
Bubble Sort	O(n^2)	Simple and educational, for small arrays
Selection Sort	O(n^2)	Better than Bubble Sort for small arrays
Insertion Sort	O(n^2)	Efficient for nearly sorted arrays

For most applications, Array.Sort is the most efficient and easy-to-use method. However, if you want to understand how sorting works internally or need a specific ordering without LINQ, implementing sorting algorithms like Bubble, Selection, and Insertion Sort can be highly educational.

---

Conclusion

Sorting arrays in C# without LINQ gives you flexibility and deeper insight into sorting mechanics. From Array.Sort to manually implementing Bubble Sort, Selection Sort, and Insertion Sort, you have various ways to achieve sorted data. Knowing these techniques allows you to choose the best method depending on the array size, structure, and performance requirements.