Cómo ordenar una array en C# | Conjunto de métodos Array.Sort() – 2

El método Array.Sort se utiliza para ordenar elementos en una array unidimensional. Hay 17 métodos en la lista de sobrecarga de este método. Aquí discutiremos los siguientes métodos:

• Ordenar (Array, Int32, Int32, IComparer) Método
• Ordenar (Array, Array, Int32, Int32, IComparer) Método
• Ordenar (Array, Int32, Int32) Método
• Ordenar (Array, Array, Int32, Int32) Método

Ordenar (Array, Int32, Int32, IComparer) Método

Este método ordena los elementos de un rango en una array unidimensional mediante un IComparer especificado .

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

Parámetros:

“arr” : Es el arreglo unidimensional a ordenar.
“start” : Es el índice de inicio del rango a ordenar.
“len” : Es el número de elementos del rango a ordenar.
“comparer”: es la implementación de IComparer para usar al comparar elementos o null para usar la implementación de IComparable de cada elemento.

Excepciones:

• ArgumentNullException: si la array es nula.
• RankException: si la array es multidimensional.
• ArgumentOutOfRangeException si el índice de inicio es menor que el límite inferior de la array o len es menor que cero.
• ArgumentException: si el índice de inicio y la longitud no especifican un rango válido en la array o si la implementación del comparador provocó un error durante la ordenación.
• InvalidOperationException: si el comparador es nulo y uno o más elementos de la array no implementan la interfaz IComparable .

Ejemplo:

// 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]);
        }
    }
}

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

Ordenar (Array, Array, Int32, Int32, IComparer) Método

Este método ordena un rango de elementos en un par de objetos de array unidimensionales en función de las claves en la primera Array mediante el IComparer especificado. Aquí los objetos contienen las claves y los elementos correspondientes.

Sintaxis: Public static void Sort (clave de array, elementos de array, int start, int len, comparador IComparer);

Parámetros:

clave: Es el arreglo unidimensional que contiene las claves a ordenar.
items: Es el array unidimensional que contiene los items que corresponden a cada una de las claves del keysArray (arreglo anterior).
inicio: Es el índice de inicio del rango a ordenar.
len: Es el número de elementos del rango a ordenar.
comparer: es la implementación de IComparer para usar al comparar elementos o null para usar la implementación de IComparable de cada elemento.

Excepciones:

• ArgumentNullException: si la clave es nula.
• RankException: si keysArray es multidimensional.
• ArgumentOutOfRangeException: si el índice de inicio es menor que el límite inferior de las claves o len es menor que cero.
• ArgumentoExcepción:
  • Si los elementos no son nulos y el límite inferior de las claves no coincide con el límite inferior de los elementos o
  • Si los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos
  • Si el índice de inicio y la longitud no especifican un rango válido en el archivo keysArray.
  • Si los elementos no son nulos, y el índice de inicio y la longitud no especifican un rango válido en itemsArray .
  • Si la implementación de comparer provocó un error durante la ordenación.
• InvalidOperationException: si el comparador es nulo.

Ejemplo:

// 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]);
        }
    }
}

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

Ordenar (Array, Int32, Int32) Método

Este método ordena los elementos de un rango en una array unidimensional mediante la implementación IComparable de cada elemento de la array.

Sintaxis: public static void Sort (Array arr, int start, int len);

Parámetros:

arr: Es el arreglo unidimensional a ordenar.
inicio: Es el índice de inicio del rango a ordenar.
len: Es el número de elementos del rango a ordenar.

Excepciones:

• ArgumentNullException: si la array es nula.
• RankException: si la array es multidimensional.
• ArgumentOutOfRangeException: si el índice de inicio es menor que el límite inferior de la array o len es menor que cero.
• ArgumentException: si el índice de inicio y la longitud no especifican un rango válido en la array.
• InvalidOperationException: si uno o más elementos de la array no implementan la interfaz IComparable .

Ejemplo:

// 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]);
        }
    }
}

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

Ordenar (Array, Array, Int32, Int32) Método

Este método ordena un rango de elementos en un par de objetos Array unidimensionales según las claves en el primer Array usando el IComparer especificado. Aquí los objetos contienen las claves y los elementos correspondientes.

Sintaxis: public static void Sort (claves de array, elementos de array, int start, int len);

Parámetros:

clave: Es el arreglo unidimensional que contiene las claves a ordenar.
items: Es el array unidimensional que contiene los items que corresponden a cada una de las claves del keysArray (arreglo anterior).
inicio: Es el índice de inicio del rango a ordenar.
len: Es el número de elementos del rango a ordenar.

Excepciones:

• ArgumentNullException: si la clave es nula.
• RankException: si keysArray es multidimensional o itemsArray es multidimensional.
• ArgumentOutOfRangeException: si el índice de inicio es menor que el límite inferior de las claves o len es menor que cero.
• ArgumentoExcepción:
  • Si los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos .
  • Si el índice de inicio y la longitud no especifican un rango válido en el archivo keysArray.
• Si los elementos no son nulos, y el índice de inicio y la longitud no especifican un rango válido en itemsArray .
• Si la implementación de comparer provocó un error durante la ordenación.

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