Cómo ordenar una array en C# | Método Array.Sort() | Juego – 4

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:
 

Método de clasificación (array)

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

Sintaxis: public static void Sort (Array arr);
Parámetro:  
arr: Es el arreglo unidimensional que se va a ordenar. 
 

Excepciones:
 

• ArgumentNullException: si la array es nula.
• RankException: si la array es multidimensional.
• InvalidOperationException: si uno o más elementos en la array no implementan la interfaz IComparable .

Ejemplo:
 

// C# program to demonstrate the
// Array.Sort(Array) method
using System;
 
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initialize two array.
        string[] arr = {"A", "E", "D",
                  "C", "F", "B", "G"};
 
        // Display original values of the array
        Console.WriteLine("The original array:");
        Display(arr);
 
        // Sort the array using two array
        Array.Sort(arr);
 
        Console.WriteLine("\n\nAfter sorting :");
        Display(arr);
    }
 
    // Display function
    public static void Display(string[] arr)
    {
        for (int i = 0; i < arr.Length; i++)
        {
            Console.Write(arr[i] + " ");
        }
    }
}

The original array:
A E D C F B G 

After sorting :
A B C D E F G

Ordenar<T>(T[], Int32, Int32, IComparer<T>) Método

Este método ordena los elementos en un rango de elementos en un Array usando la interfaz genérica IComparer<T> especificada .
 

Sintaxis: public static void Sort<T> (T[] arr, int start, int len, IComparer<T> comparer); 
Aquí T es el tipo de los elementos de la array.
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. 
comparer: es la implementación de la interfaz genérica IComparer<T> para usar al comparar elementos. 
 

Excepciones:
 

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

Ejemplo:
 

// C# program to demonstrate the use of
// Sort<T>(T[], Int32, Int32, IComparer<T>)
// Method
using System;
using System.Collections.Generic;
 
class compare : IComparer<string> {
 
    public int Compare(string x, string y)
    {
        // Compare x to y
        return x.CompareTo(y);
    }
}
 
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initializing array
        String[] arr = {"A", "D", "B",
                  "E", "C", "F", "G"};
 
        // Instantiate the IComparer object
        compare cmp = new compare();
 
        // Display the original values of the array
        Console.WriteLine("The original array:");
        display(arr);
 
        // sorting range is index 1 to 4
        // "cmp" is the IComparer<T> object
        Array.Sort(arr, 1, 4, cmp);
 
        Console.WriteLine("\nAfter sorting the array using the IComparer:");
        display(arr);
    }
 
    // display function
    public static void display(String[] arr)
    {
        foreach(String a in arr)
            Console.WriteLine(a);
    }
}

The original array:
A
D
B
E
C
F
G

After sorting the array using the IComparer:
A
B
C
D
E
F
G

Método Sort<TKey, TValue>(TKey[], TValue[])

Este método ordena un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves del primer Array mediante la implementación de la interfaz genérica  IComparable<T> de cada clave.
 

Sintaxis: public static void Sort<TKey, TValue>(TKey[] teclas, TValue[] elementos); 
Aquí, TKey es el tipo de los elementos de la array de claves y TValue el tipo de los elementos de la array de elementos.
Parámetros:  
claves: Es el arreglo unidimensional que contiene las claves a ordenar. 
items: Es el arreglo unidimensional que contiene los items que corresponden a las claves en keys. 
 

Excepciones: 
 

• ArgumentNullException: si las claves son nulas.
• ArgumentException: 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 los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos .
• InvalidOperationException: si uno o más elementos en la array de claves no implementan la interfaz genérica IComparable<T> .

Ejemplo:
 

// C# program to demonstrate the use of
// Array.Sort<TKey, TValue>(TKey[], TValue[])
// Method
using System;
using System.Collections.Generic;
 
class compare : IComparer<string> {
 
    public int Compare(string x, string y)
    {
        // Compare x to y
        return x.CompareTo(y);
    }
}
 
// Driver Class
class GFG {
 
    // Main Method
    public static void Main()
    {
        // Initialize two array
        String[] arr1 = {"H", "J", "K",
                   "L", "I", "N", "M"};
 
        String[] arr2 = {"A", "E", "D",
                   "C", "F", "B", "G"};
 
        // Instantiate the IComparer object
        compare g = new compare();
 
        // Display original values of the array
        Console.WriteLine("The original order of"+
                       " elements in the array:");
 
        Display(arr1, arr2);
 
        // Sort the array
        // "arr1" is keys array
        // "arr2" is items array
        // "g" is IComparer<T> object
        Array.Sort(arr1, arr2, g);
         
        Console.WriteLine("\nAfter Sorting: ");
        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: 
H : A
I : F
J : E
K : D
L : C
M : G
N : B