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)

 

Publicado: octubre de 2016

Ordena un intervalo de elementos en 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 implementación de la interfaz genérica IComparable<T> de cada clave.

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

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

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.

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.

InvalidOperationException

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.

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.

En el ejemplo de código siguiente se muestra laSort<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 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: