Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.Sort<T>(T[], IComparer<T>)

 

Publicado: octubre de 2016

Ordena los elementos de una Array usando la interfaz genérica IComparer<T> especificada.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public static void Sort<T>(
	T[] array,
	IComparer<T> comparer
)

Parámetros

array
Type: T[]

Array unidimensional de base cero que se va a ordenar.

comparer
Type: System.Collections.Generic.IComparer<T>

La implementación de la interfaz genérica IComparer<T> que se va a usar al comparar elementos o null para usar la implementación de la interfaz genérica IComparable<T> de cada elemento.

Parámetros de tipo

T

Tipo de los elementos de la matriz.

Exception Condition
ArgumentNullException

El valor de array es null.

InvalidOperationException

comparer es null y uno o varios elementos de array no implementan la interfaz genérica IComparable<T>.

ArgumentException

La implementación de comparer produjo un error durante la ordenación. Por ejemplo, es posible que comparer no devuelva 0 al comparar un elemento consigo mismo.

Si comparer es null, cada elemento de array debe implementar la IComparable<T> interfaz genérica para poder realizar comparaciones con los demás elementos en array.

Si la ordenación no se ha completado correctamente, los resultados son indefinidos.

Este método utiliza el algoritmo de ordenación introspectivas (introsort) como se indica a continuación:

  • Si el tamaño de partición es menos de 16 elementos, usa un insertion sort algoritmo.

  • Si el número de particiones superior a 2 * registroN, donde N es el intervalo de la matriz de entrada, utiliza un Heapsort algoritmo.

  • De lo contrario, usa un Quicksort algoritmo.

Esta implementación realiza a una ordenación inestable; es decir, si dos elementos son iguales, puede que no se conserve su orden. En cambio, una ordenación estable conserva el orden de los elementos que son iguales.

Para las matrices que se ordenan mediante el uso de los algoritmos Heapsort y Quicksort, en el peor de los casos, este método es una O (n registro n) operación, donde n es el Length de array.

Notas para llamadores:

El .NET Framework 4 y versiones anteriores utilizan solo el algoritmo Quicksort. QuickSort identifica no válido especificado en algunas situaciones en que se inicia la operación de ordenación una IndexOutOfRangeException excepción e inicia un ArgumentException excepción al llamador. A partir de la .NET Framework 4.5, es posible que las operaciones de ordenación que previamente produjo ArgumentException no producirán una excepción, porque los algoritmos de ordenación y heapsort de inserción no detectan un comparador no válido. En general, esto se aplica a las matrices con menos de 16 elementos.

En el ejemplo de código siguiente se muestra la Sort<T>(T[], IComparer<T>) sobrecarga del método genérico y el BinarySearch<T>(T[], T, IComparer<T>) sobrecarga del método genérico.

El ejemplo de código define un comparador alternativo para las cadenas, denominado ReverseCompare, que implementa el IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++) interfaz genérica. Las llamadas de comparador el CompareTo(String) método, invertir el orden de los términos de la comparación para que las cadenas ordenen alta o baja en lugar de bajo a alto.

La matriz se muestran, ordenada y vuelve a aparecer. Se deben ordenar matrices para poder usar el BinarySearch<T> método.

System_CAPS_noteNota

Las llamadas a la Sort<T>(T[], IComparer<T>) y BinarySearch<T>(T[], T, IComparer<T>) métodos genéricos no parece diferentes de las llamadas a sus homólogas no genéricas, ya que Visual Basic, C# y C++ deducen el tipo de parámetro de tipo genérico del tipo del primer argumento. Si utiliza el Ildasm.exe (IL Disassembler) para examinar el lenguaje intermedio de Microsoft (MSIL), puede ver que se llama a los métodos genéricos.

El BinarySearch<T>(T[], T, IComparer<T>) sobrecarga del método genérico, a continuación, se usa para buscar dos cadenas, una que no está en la matriz y otra que sí está. La matriz y el valor devuelto de la BinarySearch<T>(T[], T, IComparer<T>) método se pasan a la ShowWhere método genérico, que muestra el valor de índice si se encuentra la cadena y, en caso contrario, los elementos de la cadena de búsqueda que pudieran estar incluidos entre si estuviera en la matriz. El índice es negativo si la cadena no es n la matriz, por lo que la ShowWhere método toma el complemento bit a bit (el ~ operador en C# y Visual C++, Xor -1 en Visual Basic) para obtener el índice del primer elemento de la lista que es mayor que la cadena de búsqueda.

using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, 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 ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 2.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: