Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Last Updated : 06 Mar, 2019

Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method. Here we will discuss the following methods:

  • 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, Int32, Int32, IComparer) Method

This method sorts the elements in a range in a one-dimensional array using a specified IComparer.

Syntax: public static void Sort (Array arr, int start, int len, IComparer comparer);

Parameters:

“arr” :It is the one-dimensional array to sort.
“start” : It is the starting index of the range to sort.
“len” : It is the number of elements in the range to sort.
“comparer” : It is the IComparer implementation to use when comparing elements or null to use the IComparable implementation of each element.

Exceptions:

  • ArgumentNullException: If the array is null.
  • RankException: If the array is multidimensional.
  • ArgumentOutOfRangeException if the start index is less than the lower bound of array or len is less than zero.
  • ArgumentException: If the start index and len does not specify a valid range in array or if the implementation of comparer caused an error during the sort.
  • InvalidOperationException: If comparer is null, and one or more elements in array do not implement the IComparable interface.

Example:




// C# program to demonstrate the use 
// of  Array.Sort(Array, Int32, Int32, 
// IComparer) method
using System;
using System.Collections;
  
class comparer : IComparer {
  
    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(x, y);
    }
}
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // initialize a array.
        string[] arr = {"ABC", "GHI", "JKL",
                       "DEF", "MNO", "XYZ"};
  
        // Instantiate the reverse comparer.
        IComparer g = new comparer();
  
        // Display original values of the array.
        Console.WriteLine("The original order of "+
                          "elements in the array:");
        Display(arr);
  
        // Sort a section of the array
        // using the IComparer object
        // sorting happens in the range
        // of index 1 to 4
        // "g" is IComparer object
        Array.Sort(arr, 1, 4, g);
          
        Console.WriteLine("\nAfter sorting in a range of"+
             " index 1 to 4 using the IComparer object:");
  
        Display(arr);
    }
  
    // Display function
    public static void Display(string[] arr)
    {
        for (int i = arr.GetLowerBound(0); 
        i <= arr.GetUpperBound(0); i++) {
  
            Console.WriteLine(arr[i]);
        }
    }
}
Output:
The original order of elements in the array:
ABC
GHI
JKL
DEF
MNO
XYZ

After sorting in a range of index 1 to 4 using the IComparer object:
ABC
DEF
GHI
JKL
MNO
XYZ

Sort(Array, Array, Int32, Int32, IComparer) Method
This method sorts a range of elements in a pair of one-dimensional array objects based on the keys in the first Array using the specified IComparer. Here the objects contain the keys and the corresponding items.
Syntax: public static void Sort (Array key, Array items, int start, int len, IComparer comparer);
Parameters:
key: It is the one-dimensional array which contains the keys to sort.
items: It is the one-dimensional array which contains the items that correspond to each of the keys in the keysArray(previous array).
start: It is the starting index of the range to sort.
len: It is the number of elements in the range to sort.
comparer: It is the IComparer implementation to use when comparing elements or null to use the IComparable implementation of each element.
Exceptions:
  • ArgumentNullException: If the key is null.
  • RankException: If the keysArray is multidimensional.
  • ArgumentOutOfRangeException: If the start index is less than the lower bound of keys or len is less than zero.
  • ArgumentException:
    • If the items is not null, and the lower bound of keys does not match the lower bound of items or
    • If the items is not null, and the len of keys is greater than the length of items
    • If the start index and len do not specify a valid range in the keysArray.
    • If the items is not null, and start index and len do not specify a valid range in the itemsArray.
    • If the implementation of comparer caused an error during the sort.
  • InvalidOperationException: If the comparer is null.
Example:



// C# program to demonstrate the use 
// of Array.Sort(Array, Array, Int32,
// Int32, IComparer) Method
using System;
using System.Collections;
  
class comparer : IComparer {
  
    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(y, x);
    }
}
  
// Driver Class
class GFG {
  
    // Main Method
    public static void Main()
    {
        // initialize two Arrays
        String[] arr1 = {"H", "J", "K",
                   "L", "I", "N", "M"};
  
        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};
  
        // Instantiate the reverse comparer.
        IComparer g = new comparer();
  
        // Display original values of the array.
        Console.WriteLine("The original order of "+
                         "elements in the array:");
  
        Display(arr1, arr2);
  
        // Sort a section of the array 
        // using the IComparer object
        // sorting happens in the range
        // of index 1 to 4
        // "g" is IComparer object
        Array.Sort(arr1, arr2, 1, 4, g);
          
        Console.WriteLine("\nAfter sorting in a "+
                       "range of index 1 to 4 :");
  
        Display(arr1, arr2);
    }
  
    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++) 
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}
Output:
The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
N : B
M : G

After sorting in a range of index 1 to 4 :
H : A
L : C
K : D
J : E
I : F
N : B
M : G

Sort(Array, Int32, Int32) Method
This method sorts the elements in a range in a one-dimensional array using the IComparable implementation of each element of the Array.
Syntax: public static void Sort (Array arr, int start, int len);
Parameters:
arr: It is the one-dimensional array to sort.
start: It is the starting index of the range to sort.
len: It is the number of elements in the range to sort.
Exceptions:
  • ArgumentNullException: If the array is null.
  • RankException: If the array is multidimensional.
  • ArgumentOutOfRangeException: If the start index is less than the lower bound of array or len is less than zero.
  • ArgumentException: If the start index and len does not specify a valid range in array.
  • InvalidOperationException: If the one or more elements in array do not implement the IComparable interface.
Example:



// C# program to demonstrate the use of
// Array.Sort(Array, Int32, Int32) method
using System;
using System.Collections;
  
class GFG {
  
    // Main Method
    public static void Main()
    {
        // initialize a array.
        string[] arr = {"ABC", "GHI", "JKL",
                       "DEF", "MNO", "XYZ"};
  
        // Display original values of the array.
        Console.WriteLine("The original order of"+
                       " elements in the array:");
  
        Display(arr);
  
        // sorting happens in the
        // range of index 1 to 4
        Array.Sort(arr, 1, 4);
  
        Console.WriteLine("\nAfter sorting in a range of "+
               "index 1 to 4 using the IComparer object:");
  
        Display(arr);
    }
  
    // Display function
    public static void Display(string[] arr)
    {
        for (int i = arr.GetLowerBound(0); 
        i <= arr.GetUpperBound(0); i++) {
  
            Console.WriteLine(arr[i]);
        }
    }
}
Output:
The original order of elements in the array:
ABC
GHI
JKL
DEF
MNO
XYZ

After sorting in a range of index 1 to 4 using the IComparer object:
ABC
DEF
GHI
JKL
MNO
XYZ

Sort(Array, Array, Int32, Int32) Method
This method sorts a range of elements in a pair of one-dimensional Array objects based on the keys in the first Array using the specified IComparer. Here the objects contain the keys and the corresponding items.
Syntax: public static void Sort (Array keys, Array items, int start, int len);
Parameters:
key: It is the one-dimensional array which contains the keys to sort.
items: It is the one-dimensional array which contains the items that correspond to each of the keys in the keysArray(previous array).
start: It is the starting index of the range to sort.
len: It is the number of elements in the range to sort.
Exceptions:
  • ArgumentNullException: If the key is null.
  • RankException: If the keysArray is multidimensional or the itemsArray is multidimensional.
  • ArgumentOutOfRangeException: If the start index is less than the lower bound of keys or len is less than zero.
  • ArgumentException:
    • If the items is not null, and the len of keys is greater than the length of items.
    • If the start index and len do not specify a valid range in the keysArray.
    • If the items is not null, and start index and len do not specify a valid range in the itemsArray.
    • If the implementation of comparer caused an error during the sort.
  • InvalidOperationException: If one or more elements in the keysArray do not implement the IComparable interface.
Example:



// C# program to demonstrate the use of
// Array.Sort(Array, Int32, Int32, 
// IComparer) method
using System;
using System.Collections;
  
class comparer : IComparer {
  
    // Call CaseInsensitiveComparer.Compare
    public int Compare(Object x, Object y)
    {
        return (new CaseInsensitiveComparer()).Compare(y, x);
    }
}
  
// Driver Class
class GFG {
  
    // Main Method
    public static void Main()
    {
        // initialize two arrays
        String[] arr1 = {"H", "J", "K", 
                   "L", "I", "N", "M"};
  
        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};
  
        // Display original values of the array.
        Console.WriteLine("The original order of elements in the array:");
        Display(arr1, arr2);
  
        // sorting happens in the range of index 1 to 4
        Array.Sort(arr1, arr2, 1, 4);
  
        Console.WriteLine("\nAfter sorting in a "+
                       "range of index 1 to 4 :");
  
        Display(arr1, arr2);
    }
  
    // Display function
    public static void Display(String[] arr1, String[] arr2)
    {
        for (int i = 0; i < arr1.Length; i++) 
        {
            Console.WriteLine(arr1[i] + " : " + arr2[i]);
        }
    }
}
Output:
The original order of elements in the array:
H : A
J : E
K : D
L : C
I : F
N : B
M : G

After sorting in a range of index 1 to 4 :
H : A
I : F
J : E
K : D
L : C
N : B
M : G

Reference:

My Personal Notes
arrow_drop_up
Previous
Perl | Exiting from a Script
Next

GRE Quiz | GRE Quantitative 2 | Question 1
Recommended Articles
Page :
How to sort an Array in C# | Array.Sort() Method Set - 1
13, Feb 19
How to sort an Array in C# | Array.Sort() Method Set – 3
12, Mar 19
How to sort an Array in C# | Array.Sort() Method | Set – 4
13, Mar 19
How to sort an Array in C# | Array.Sort() Method | Set – 5
15, Mar 19
How to sort a list in C# | List.Sort() Method Set -1
18, Jan 19
How to sort a list in C# | List.Sort() Method Set -2
12, Feb 19
Count swaps required to sort an array using Insertion Sort
21, Jan 21
Serial Sort v/s Parallel Sort in Java
03, Apr 17
Difference between Insertion sort and Selection sort
11, Jan 21
Sort elements by frequency | Set 5 (using Java Map)
12, Oct 18
C# Program to Sort a List of Integers Using the LINQ OrderBy() Method
03, Dec 21
C# Program to Sort a List of String Names Using the LINQ OrderBy() Method
03, Dec 21
Find array with k number of merge sort calls
09, Nov 17
Check if it is possible to sort the array after rotating it
23, Oct 18
Different ways to sort an array in descending order in C#
30, Nov 18
Sort the array in a given index range
13, Dec 18
How to sort an array in a single loop?
16, Dec 19
Java Program to Sort the Array Elements in Descending Order
18, Nov 20
Java Program to Check if it is possible to sort the array after rotating it
23, Dec 21
Minimum number of jumps required to sort the given array in ascending order
15, Mar 21
C++ Program to Check if it is possible to sort the array after rotating it
23, Dec 21
Python3 Program to Check if it is possible to sort the array after rotating it
23, Dec 21
How to Sort Object Array By Specific Property in C#?
22, Jan 22
Find array elements with rightmost set bit at the position of the rightmost set bit in K
09, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
SoumikMondal
@SoumikMondal
Vote for difficulty





Article Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!