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

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

  1. Sort<T>(T[]) Method
  2. Sort<T>(T[], IComparer<T>) Method
  3. Sort<T>(T[], Int32, Int32) Method
  4. Sort<T>(T[], Comparison<T>) Method
  5. Sort(Array, Int32, Int32, IComparer) Method
  6. Sort(Array, Array, Int32, Int32, IComparer) Method
  7. Sort(Array, Int32, Int32) Method
  8. Sort(Array, Array, Int32, Int32) Method
  9. Sort(Array, IComparer) Method
  10. Sort(Array, Array, IComparer) Method
  11. Sort(Array, Array) Method
  12. Sort(Array) Method
  13. Sort<T>(T[], Int32, Int32, IComparer<T>) Method
  14. Sort<TKey,TValue>(TKey[], TValue[]) Method
  15. Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Method
  16. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Method
  17. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Method

Here we will discuss the first 4 methods.

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: public static void Sort (T[] array);

Parameter:
array: It is the one dimensional, zero-based Array which is to be sorted.

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to illustrate the use 
// of the Array.Sort<T>(T[]) Method
using System;
using System.Collections.Generic;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // array elements
        string[] arr = new string[5] { "A"
                      "D", "X", "G", "M" };
  
        foreach(string g in arr)
        {
            Console.WriteLine(g);
            // display original array
        }
  
        Console.WriteLine("\nAfter Sort:");
        Array.Sort(arr);
  
        foreach(string g in arr)
        {
            Console.WriteLine(g);
            // display sorted array
        }
  
        Console.WriteLine("\nB sorts between :");
  
        // binary Search for "B"
        int index = Array.BinarySearch(arr, "B");
  
        // call "sortT" function
        // which is the Sort<T>(T[]) 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 the index is negative, 
        // it represents the bitwise
        // complement of the next larger 
        // element in the array.
        if (index < 0) {
              
            index = ~index;
  
            if (index == 0)
                Console.Write("beginning of array");
            else
                Console.Write("{0} and ", arr[index - 1]);
  
            if (index == arr.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}", arr[index]);
        }
    }
}

chevron_right


Output:

A
D
X
G
M

After Sort:
A
D
G
M
X

B sorts between :
A and D

F sorts between :
D and G

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, System.Collections.Generic.IComparer<T> comparer);

Parameters:

  • T : It is the type of the elements of the array.
  • array : It is the one-dimensional Array which is to be sorted.
  • comparer : It is the IComparer<T> generic interface implementation to use when comparing elements or null to use the IComparable<T> generic interface implementation of each element.

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# progrm 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.
        return x.CompareTo(y);
    }
}
  
class GFG {
  
    // Main Method
    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);
        }
    }
}

chevron_right


Output:

A
D
X
G
M

After Sort: 
A
D
G
M
X

D Sorts between :
Found at index 1.

F Sorts between :
Not found. Sorts between: D and G.

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

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

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

Parameters:

  • array: It is the one-dimensional, zero-based Array to sort.
  • index: It is the starting index of the range to sort.
  • length: It is the number of elements in the range to sort.

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 Example {
  
    // Main Method
    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 in 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 in 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);
        }
    }
}

chevron_right


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

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

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

Syntax: public static void Sort<T> (T[] array, Comparison<T> comparison);

Parameters:

  • array: It is the one-dimensional zero-based Array which is to be sorted.
  • comparison: It is the comparison<T> to used when comparing elements.

Exceptions:

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

Example:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to demonstrate the use of the 
// Array.Sort<T>(T[ ], Comparison<T>) Method
using System;
using System.Collections.Generic;
  
class GFG {
      
    private static int CompareComp(string x, string y)
    {
        if (y == null && x == null) {
              
            // If x and y is null
            // then x and y are same
            return 0;
        }
        else {
              
            // If x is null but y is not 
            // null then y is greater.
            return -1;
        }
    }
  
    // Main method
    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);
        }
    }
}

chevron_right


Output:

Original Array: 
Java
C++
Scala
C
Ruby
Python

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

Reference:



My Personal Notes arrow_drop_up