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:
- 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
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> (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:
// 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]);
}
}
} |
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:
// 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.
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);
}
}
} |
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:
// 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);
}
}
} |
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:
// 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);
}
}
} |
Output:
Original Array: Java C++ Scala C Ruby Python Sort with Comparison: Python Ruby C Scala C++ Java
Reference: