Topic 4818 min readStructured Tutorial

Array Sorting in C#

Quick Answer

In C#, arrays can be sorted using the Array.Sort() method, which sorts elements in ascending order by default. You can also use custom comparers or LINQ for more advanced sorting scenarios. Sorting arrays is essential for organizing data efficiently in applications.

Learning Objectives

Explain the purpose of Array Sorting in a practical learning context.
Identify the main ideas, terms, and decisions involved in Array Sorting.
Apply Array Sorting in a simple real-world scenario or practice task.

Introduction

Sorting arrays is a fundamental operation in programming that helps organize data for efficient access and processing.

C# provides several ways to sort arrays, including built-in methods and LINQ queries, making it easy to handle different sorting needs.

Sorting is the foundation of efficient data processing.

Using Array.Sort() Method

The simplest way to sort an array in C# is by using the static Array.Sort() method. It sorts the array elements in ascending order by default.

This method modifies the original array in place and works with arrays of any type that implements IComparable.

Sorts elements in ascending order by default.
Modifies the original array.
Works with primitive types and objects implementing IComparable.

Example: Sorting an Integer Array

Here is a simple example demonstrating how to sort an integer array using Array.Sort():

Sorting with Custom Comparers

Sometimes you need to sort arrays based on custom criteria. C# allows you to pass a custom comparer to Array.Sort() to define your own sorting logic.

You can implement the IComparer interface or use a Comparison delegate for this purpose.

Create a class implementing IComparer<T> to define custom sorting.
Use Comparison<T> delegate for inline sorting logic.
Useful for sorting complex objects or descending order.

Example: Sorting Strings by Length

This example shows how to sort an array of strings by their length using a custom comparer.

Sorting Arrays Using LINQ

LINQ provides a powerful and expressive way to sort arrays without modifying the original array.

You can use the OrderBy and OrderByDescending methods to create sorted sequences.

Does not modify the original array; returns a new sorted sequence.
Supports complex sorting with lambda expressions.
Can chain multiple sorting criteria using ThenBy.

Example: Sorting an Array with LINQ

Here is how to sort an array of integers in descending order using LINQ:

Practical Example

This example sorts the integer array in ascending order and prints the sorted elements.

This example sorts the string array by the length of each string using a lambda expression as a custom comparer.

This example uses LINQ to sort the array in descending order without modifying the original array.

Examples

Sorting an Integer Array with Array.Sort()

int[] numbers = { 5, 3, 8, 1, 4 };
Array.Sort(numbers);
foreach (int num in numbers)
{
    Console.WriteLine(num);
}

This example sorts the integer array in ascending order and prints the sorted elements.

Sorting Strings by Length Using a Custom Comparer

string[] words = { "apple", "banana", "cherry", "date" };
Array.Sort(words, (x, y) => x.Length.CompareTo(y.Length));
foreach (string word in words)
{
    Console.WriteLine(word);
}

This example sorts the string array by the length of each string using a lambda expression as a custom comparer.

Sorting an Array in Descending Order Using LINQ

int[] numbers = { 5, 3, 8, 1, 4 };
var sortedDesc = numbers.OrderByDescending(n => n);
foreach (int num in sortedDesc)
{
    Console.WriteLine(num);
}

This example uses LINQ to sort the array in descending order without modifying the original array.

Best Practices

Use Array.Sort() for simple ascending sorts to leverage built-in performance.
Use custom comparers when sorting complex objects or non-default criteria.
Use LINQ for non-destructive sorting or when chaining multiple sort conditions.
Always consider the mutability of your data when choosing a sorting method.

Common Mistakes

Assuming Array.Sort() returns a new sorted array instead of sorting in place.
Not implementing IComparable or IComparer correctly for custom sorting.
Modifying the original array unintentionally when using Array.Sort().
Using LINQ sorting without realizing it returns an IEnumerable, not an array.

Hands-on Exercise

Sort an Array of Custom Objects

Create a class Person with properties Name and Age. Create an array of Person objects and sort it by Age using Array.Sort() with a custom comparer.

Expected output: Array of Person objects sorted by Age in ascending order.

Hint: Implement IComparer<Person> or use a Comparison<Person> delegate.

Sort an Array Using LINQ

Given an array of strings, use LINQ to sort them alphabetically and print the sorted list without modifying the original array.

Expected output: Alphabetically sorted list of strings printed to the console.

Hint: Use OrderBy method and remember LINQ returns IEnumerable.

Interview Questions

How does Array.Sort() work in C#?

Interview

Array.Sort() sorts the elements of an array in place using the QuickSort algorithm by default, ordering elements in ascending order based on their IComparable implementation.

How can you sort an array in descending order in C#?

Interview

You can sort an array in descending order by using Array.Sort() with a custom comparer that reverses the comparison, or by using LINQ's OrderByDescending method.

What is the difference between Array.Sort() and LINQ sorting?

Interview

Array.Sort() sorts the original array in place, modifying it, while LINQ sorting methods return a new sorted sequence without changing the original array.