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, IComparer) Método
- Método Ordenar (Array, Array, IComparer)
- Ordenar (Array, Array) Método
Ordenar (Array, IComparer) Método
Este método ordena los elementos en una array unidimensional utilizando un IComparer especificado .
Sintaxis: public static void Sort (Array arr, IComparer comparer);
Parámetros:
arr: Es el arreglo unidimensional a ordenar.
comparer: Es la implementación a utilizar al comparar elementos.
Excepciones:
- ArgumentNullException: si la array arr es nula.
- RankException: si la array arr es multidimensional.
- InvalidOperationException: si el comparador es nulo.
- ArgumentException: si la implementación del comparador provocó un error durante la ordenación.
Ejemplo 1:
// C# program to demonstrate the
// Array.Sort(Array, IComparer) method
using System;
using System.Collections;
class compare : 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()
{
// Initializing array.
String[] arr = {"A", "D", "B",
"E", "C", "F", "G"};
// Instantiate the IComparer object
IComparer cmp = new compare();
// Display the original values of the array
Console.WriteLine("The Original array:");
display(arr);
// Sort the entire array by using
// the IComparer object
// "cmp" is the IComparer object
Array.Sort(arr, 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
Ejemplo 2:
// C# program to demonstrate the
// Array.Sort(Array, IComparer) method
using System;
using System.Collections;
class compare : 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()
{
// Initializing array.
int[] arr = {10, 1, 9, 8, 3,
4, 6, 5, 2, 7};
// Instantiate the IComparer object
IComparer cmp = new compare();
// Display the original values of the array
Console.WriteLine("The Original array:");
display(arr);
// Sort the entire array by
// using the IComparer object
// "cmp" is the IComparer object
Array.Sort(arr, cmp);
Console.WriteLine("\n\nAfter sorting the "+
"array using the IComparer:");
display(arr);
}
// display function
public static void display(int[] arr)
{
foreach(int a in arr)
Console.Write(a + " ");
}
}
The Original array: 10 1 9 8 3 4 6 5 2 7 After sorting the array using the IComparer: 1 2 3 4 5 6 7 8 9 10
Método Ordenar (Array, Array, IComparer)
Este método ordena un par de objetos de array unidimensionales en función de las claves de la primera array mediante el IComparer especificado .
Sintaxis: Public static void Sort (claves de array, elementos de array, comparador IComparer);
Parámetros:
claves: Es el arreglo unidimensional que contiene las claves a ordenar.
items: Es la array unidimensional que contiene los elementos que corresponden a cada una de las claves en la array de claves .
comparer: es la implementación de IComparer para usar al comparar elementos.
Excepciones:
- ArgumentNullException: si las claves son nulas.
- RankException: si la array de claves es multidimensional o la array de elementos es multidimensional.
- ArgumentException: si los elementos no son nulos y la longitud de las claves es mayor que la longitud de los elementos 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
// Array.Sort(Array, Array,
// 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 two arrays
String[] arr1 = {"H", "J", "K",
"L", "I", "N", "M"};
String[] arr2 = {"A", "E", "D",
"C", "F", "B", "G"};
// Instantiate the IComparer object
IComparer g = new comparer();
// Display original values of the array.
Console.WriteLine("The original order of "+
"elements in the array:");
Display(arr1, arr2);
// Sort the array using IComparer
// object. "g" is IComparer 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
Ordenar (Array, Array) Método
Este método ordena un par de objetos de array unidimensionales en función de las claves del primer Array mediante la implementación IComparable de cada clave. Aquí, en los objetos hay dos arrays en las que una contiene las claves y la otra contiene los elementos correspondientes.
Sintaxis: Public static void Sort (claves de array, elementos de array);
Parámetros:
claves: Es el arreglo unidimensional que contiene las claves a ordenar.
items: Es la array unidimensional que contiene los elementos que corresponden a cada una de las claves en la array de claves .
Excepciones:
- ArgumentNullException: si las claves son nulas.
- RankException: si la array de claves es multidimensional o la array de elementos es multidimensional.
- ArgumentException: si 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 IComparable .
Ejemplo:
// C# program to demonstrate the
// Array.Sort(Array, Array) method
using System;
class GFG {
// Main Method
public static void Main()
{
// initialize two array.
int[] arr1 = {7, 5, 2, 3, 1, 6, 4};
string[] arr2 = {"A", "E", "D",
"C", "F", "B", "G"};
// Display original values of the array.
Console.WriteLine("The original array:");
Display(arr1, arr2);
// Sort the array using two array
// "arr1" is keys array
// "arr2" item array
Array.Sort(arr1, arr2);
Console.WriteLine("\nAfter Sorting :");
Display(arr1, arr2);
}
// Display function
public static void Display(int[] arr1, string[] arr2)
{
for (int i = 0; i < arr1.Length; i++)
{
Console.WriteLine(arr1[i] + " : " + arr2[i]);
}
}
}
The original array: 7 : A 5 : E 2 : D 3 : C 1 : F 6 : B 4 : G After Sorting : 1 : F 2 : D 3 : C 4 : G 5 : E 6 : B 7 : A
Referencia:
Publicación traducida automáticamente
Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA