How to Sort an Array in C# | Array.Sort() Method Set - 1

Last Updated : 04 Feb, 2025

Array.Sort Method in C# is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method as follows:

Sort<T>(T[]) Method
Sort<T>(T[], IComparer<T>) Method
Sort<T>(T[], Int32, Int32) Method
Sort<T>(T[], Comparison<T>) Method
Sort(Array, Int32, Int32, IComparer) Method
Sort(Array, Array, Int32, Int32, IComparer) Method
Sort(Array, Int32, Int32) Method
Sort(Array, Array, Int32, Int32) Method
Sort(Array, IComparer) Method
Sort(Array, Array, IComparer) Method
Sort(Array, Array) Method
Sort(Array) Method
Sort<T>(T[], Int32, Int32, IComparer<T>) Method
Sort<TKey,TValue>(TKey[], TValue[]) Method
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Method
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Method
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Method

In this article, we will discuss the first 4 methods.

Sort an Array in C#

1. Sort<T>(T[]) Method

This method sorts the elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Syntax:

Array.Sort<T>(T[] array);

Parameter: T[] array is a one-dimensional array of type T that you want to sort, T can be any type that implements the IComperable<T> interface.

Return Type: This method does not return a value. it sorts the array in place.

Exceptions:

ArgumentNullException: If the array is null.
InvalidOperationException: If one or more elements in the array do not implement the IComparable<T> generic interface.

Example: This example demonstrates how to sort an array, perform a binary search for specific elements and determine their potential insertion positions in a sorted array.

// C# Program to demomstrates the use  
// of the Array.Sort<T>(T[]) Method 
using System;

class Geeks
{
    public static void Main()
    {
        // array elements
        string[] arr = new string[5] { "A", "D", "X", "G", "M" };

        // Display original array
        Console.WriteLine("Original Array:");
        foreach (string g in arr)
        {
            Console.WriteLine(g);
        }

        Console.WriteLine("\nAfter Sort:");
      
        // Sorting the array
        Array.Sort(arr);

        // Display sorted array
        foreach (string g in arr)
        {
            Console.WriteLine(g);
        }

        Console.WriteLine("\nBinary Search for 'B':");
      
        // Binary Search for "B"
        int index = Array.BinarySearch(arr, "B");
        sortT(arr, index);

        Console.WriteLine("\nBinary Search for 'F':");
      
        // Binary Search for "F"
        index = Array.BinarySearch(arr, "F");
        sortT(arr, index);
    }

    public static void sortT<T>(T[] arr, int index)
    {
        // If the index is negative, it represents the 
        // bitwise complement of the next larger element
        if (index < 0)
        {
          
            // Convert to the actual index of 
            // the next larger element
            index = ~index;  

            if (index == 0)
                Console.WriteLine("Element would be inserted at the beginning of the array.");
            else
                Console.WriteLine($"Element would be inserted between {arr[index - 1]} and {arr[index]}.");
            
            if (index == arr.Length)
                Console.WriteLine("Element would be inserted at the end of the array.");
        }
        else
        {
            Console.WriteLine($"Element 'B' or 'F' found at index {index}.");
        }
    }
}

Output

Original Array:
A
D
X
G
M

After Sort:
A
D
G
M
X

Binary Search for 'B':
Element would be inserted between A and D.

Binary Search for 'F':
Element would be inserted between D and G.

2. Sort<T>(T[], IComparer<T>) Method

This method Sorts the elements in an Array using the specified IComparer<T> generic interface.

Syntax:

public static void Sort<T>(T[] array, IComparer<T> comparer);

Parameter: Thie method takes to parameters

T[] array: An array of elements of type T to be sorted
ICOmparer<T>comparer: An object that implements the IComparer<T> interface, used to define the custom comparison logic for the array elements.

Return Type: This method does not return a value. it sorts the array in place.

Exceptions:

ArgumentNullException: If the array is null.
InvalidOperationException: If the comparer is null and there is no implementation of the IComparable<T> generic interface.
ArgumentException: If the implementation of comparer caused an error during the sort.

Example: This example demonstrates how to sort an array in reverse order using cutrom compare and perform binary searches to find or determine the insertion point of specific elements.

// C# program to demonstrate the use of the  
// Array.Sort<T>(T[], IComparer<T>) method 
using System;
using System.Collections.Generic;

public class GeeK : IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare x and y in reverse order
        // Reverse the order by swapping x and y
        return y.CompareTo(x);  
    }
}

class Geeks
{  
    public static void Main()
    {
        // array elements
        string[] arr = new string[5] { "A", "D", "X", "G", "M" };

        foreach (string g in arr)
        {
            // display original array
            Console.WriteLine(g);
        }

        Console.WriteLine("\nAfter Sort: ");
        GeeK gg = new GeeK();

        // Sort<T>(T[], IComparer<T>) method
        Array.Sort(arr, gg);

        foreach (string g in arr)
        {
            // display sorted array
            Console.WriteLine(g);
        }

        Console.WriteLine("\nD Sorts between :");

        // binary Search for "D"
        int index = Array.BinarySearch(arr, "D");

        // call "sortT" function
        sortT(arr, index);

        Console.WriteLine("\nF Sorts between :");
        index = Array.BinarySearch(arr, "F");
        sortT(arr, index);
    }

    public static void sortT<T>(T[] arr, int index)
    {
        if (index < 0)
        {
            // If the index is negative,
            // it represents the bitwise
            // complement of the next
            // larger element in the array.
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("Beginning of array and ");
            else
                Console.Write("{0} and ", arr[index - 1]);

            if (index == arr.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", arr[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

Output

A
D
X
G
M

After Sort: 
X
M
G
D
A

D Sorts between :
Not found. Sorts between: Beginning of array and X.

F Sorts between :
Not found. Sorts between: Beginning of array and X.

3. Array.Sort<T>(T[], Int32, Int32) Method

This method sorts a range of elements in an array, specified by the starting index(Int 32) and the length(Int32) of the range. It uses the IComparable<T> interface of each element in the array to perform the sorting.

Syntax:

public static void Sort<T>(T[] array, int index, int length);

Parameter: This method takes three parameters

array(T[]): The array to be sorted
index(Int32): The starting index of the range to sort.
Length(Int32): he number of elements to sort, starting from the specified index.

Return Type: This method does not return a value. it sorts the array in place.

Exceptions:

ArgumentNullException: If the array is null.
ArgumentOutOfRangeException: If the index is less than the lower bound of array or length is less than zero.
ArgumentException: If the index and length do not specify a valid range in the array.
InvalidOperationException: If one or more elements in the array do not implement the IComparable<T> generic interface.

Example: This example demonstrates sorting a specified range of an array both in default and reverse order using Array.Sort with or without custom comparer.

// C# program to demonstrate the use of 
// Array.Sort<T>(T[], Int32, Int32) method 
using System;
using System.Collections.Generic;

public class Geek : IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order
        return y.CompareTo(x);
    }
}
public class Geeks
{
    
    public static void Main()
    {
        // Array elements
        string[] arr = { "AB", "CD", "GH", "EF", "MN", "IJ" };

        Console.WriteLine("Original Array :");
        Display(arr);

        Console.WriteLine("\nSort the array between index 1 to 4");
      
        // Array.Sort(T[], Int32, Int32) method
        // Sort will happen between index 1 to 4
        Array.Sort(arr, 1, 4);
        Display(arr);

        Console.WriteLine("\nSort the array reversely in between index 1 to 4");
      
        // Sort will happen between index 1 to 4 reversely
        Array.Sort(arr, 1, 4, new Geek());
        Display(arr);
    }

    public static void Display(string[] arr)
    {
        foreach (string g in arr)
        {
            Console.WriteLine(g);
        }
    }
}

Output

Original Array :
AB
CD
GH
EF
MN
IJ

Sort the array between index 1 to 4
AB
CD
EF
GH
MN
IJ

Sort the array reversely in between index 1 to 4
AB
MN
GH
EF
CD
IJ

4. Array.Sort<T>(T[], Comparison<T>) Method

This method sorts the elements in an Array using the specified Comparison<T>.

Syntax:

Array.Sort<T>(T[] array, Comparison<T> comparison)

Parameters: This method takes two parameters

array: The array of type T[] that you want to sort.
Comparison<T> comparison: A Comparison<T> de;egate that defines the sort order. This delegate compares two elements of the array.

Return Type: This method does not return a value. it sorts the array in place.

Exceptions:

ArgumentNullException: If the array is null or comparison is null.
ArgumentException: If the implementation of comparison caused an error during the sort.

Example: This example demonstrates how to sort an array of strings using a custom comparison function that handles null values and compares non-null strings lexicographically.

// C# program to demonstrate the use of the 
// Array.Sort<T>(T[ ], Comparison<T>) Method 
using System; 
using System.Collections.Generic; 

class Geeks { 
	
	private static int CompareComp(string x, string y) 
	{ 
		// Handle null values first
		if (x == null && y == null) { 
          
			// If both x and y are null, they're equal
			return 0; 
		} else if (x == null) { 
          
			// If x is null but y is not, y is greater
			return 1; 
		} else if (y == null) { 
          
			// If y is null but x is not, x is greater
			return -1; 
		} else { 
          
			// Compare non-null values
			return string.Compare(x, y); 
		} 
	} 

	public static void Main() 
	{ 
		string[] arr = { "Java", "C++", "Scala", 
						"C", "Ruby", "Python" }; 
		
		Console.WriteLine("Original Array: "); 
		
		// display original array 
		Display(arr); 
		
		Console.WriteLine("\nSort with Comparison: "); 

		// Array.Sort<T>(T[], Comparison<T>) 
		// Method 
		Array.Sort(arr, CompareComp); 
		
		// display sorted array 
		Display(arr); 
		
	} 
	// Display function 
	public static void Display(string[] arr) 
	{ 
		foreach (string g in arr) 
		{ 
			Console.WriteLine(g); 
		} 
	} 
}

Output

Original Array: 
Java
C++
Scala
C
Ruby
Python

Sort with Comparison: 
C
C++
Java
Python
Ruby
Scala

How to find the rank of an array in C#

SoumikMondal

Improve

Article Tags :

How to Sort an Array in C# | Array.Sort() Method Set - 1

Sort an Array in C#

1. Sort<T>(T[]) Method

2. Sort<T>(T[], IComparer<T>) Method

3. Array.Sort<T>(T[], Int32, Int32) Method

4. Array.Sort<T>(T[], Comparison<T>) Method

Similar Reads

Introduction

Fundamentals

Control Statements

OOP Concepts

Methods

Arrays

ArrayList

String

Tuple

Indexers

Thank You!

What kind of Experience do you want to share?