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<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

 

Publicado: noviembre de 2016

Ordena un intervalo de elementos de un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la interfaz genérica IComparer<T> especificada.

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

public static void Sort<TKey, TValue>(
	TKey[] keys,
	TValue[] items,
	int index,
	int length,
	IComparer<TKey> comparer
)

Parámetros

keys
Type: TKey[]

Array unidimensional de base cero que contiene las claves que se van a ordenar.

items
Type: TValue[]

Matriz Array unidimensional de base cero que contiene los elementos que se corresponden con las claves del parámetro keys; o null para ordenar solo keys.

index
Type: System.Int32

Índice inicial del intervalo que se va a ordenar.

length
Type: System.Int32

Número de elementos del intervalo que se va a ordenar.

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

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

Parámetros de tipo

TKey

Tipo de los elementos de la matriz de claves.

TValue

Tipo de los elementos de la matriz de elementos.

Exception Condition
ArgumentNullException

El valor de keys es null.

ArgumentOutOfRangeException

index es menor que el límite inferior de keys.

-o-

length es menor que cero.

ArgumentException

items no es null y el límite inferior de keys no coincide con el límite inferior de items.

-o-

items no es null y la longitud de keys es mayor que la longitud de items.

-o-

index y length no especifican un intervalo válido en keysArray.

-o-

items no es null y index y length no especifican un intervalo válido en itemsArray.

-o-

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.

InvalidOperationException

comparer es null y uno o más elementos de keysArray no implementan la interfaz genérica IComparable<T>.

Cada clave de la keysArray tiene un elemento correspondiente en el itemsArray. Cuando se cambia la posición de una clave durante la ordenación, el elemento correspondiente de la itemsArray se vuelve a colocar de forma similar. Por lo tanto, la itemsArray se ordenan en función de la organización de las claves correspondientes en el keysArray.

Si comparer es null, cada clave dentro del intervalo especificado de elementos de la keysArray debe implementar la IComparable<T> interfaz genérica para poder realizar comparaciones con todas las demás claves.

Puede ordenar si hay más elementos que las claves, pero no se ordenará los elementos que no tengan ninguna de las claves correspondientes. No se puede ordenar si hay más teclas que elementos; al hacerlo se inicia una ArgumentException.

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 length.

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<TKey, TValue>(TKey[], TValue[]), Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32), y Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) sobrecargas de método genérico, para ordenar los pares de matrices que representan las claves y valores.

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.

El ejemplo de código se crea y muestra una matriz de nombres de dinosaurio (las claves) y una matriz de enteros que representa la longitud máxima de cada dinosaurio en metros (los valores). Las matrices, a continuación, se ordena y se muestran varias veces:

System_CAPS_noteNota

Las llamadas a los 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 de los dos primeros argumentos. 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.

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 = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

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

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */

Plataforma universal de Windows
Disponible desde 10
.NET Framework
Disponible desde 2.0
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: