Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

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

Ordena los elementos de una matriz Array utilizando 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 de tipo

T

Tipo de los elementos de la matriz.

Parámetros

array
Tipo: T[]
Matriz Array unidimensional de base cero que se va a ordenar.
comparer
Tipo: System.Collections.Generic.IComparer<T>
Implementación de la interfaz genérica IComparer<T> que se va a utilizar para comparar elementos o null si se va a utilizar la implementación de la interfaz genérica IComparable<T> de cada elemento.

ExcepciónCondición
ArgumentNullException

array es null.

InvalidOperationException

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

ArgumentException

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

Si el valor de comparer es null, cada elemento de array debe implementar la interfaz genérica IComparable<T> para que se puedan realizar comparaciones con todos los demás elementos de array.

Si la ordenación no se realiza correctamente, los resultados quedarán sin definir.

Este método utiliza el algoritmo introspectivo sort (introsort) como sigue:

  • Si el tamaño de la partición es menor que 16 elementos, utiliza ordenación de inserción un algoritmo.

  • Si el número de particiones supera 2 * registrarf, donde es el intervalo f de la matriz de entrada, utiliza Heapsort un algoritmo.

  • Si no, utiliza Quicksort un algoritmo.

Esta implementación realiza una ordenación inestable; es decir, si hay dos elementos iguales, es posible que no se mantenga su orden. En contraste, una ordenación estable conserva el orden de los elementos que son iguales.

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

Notas para los llamadores

.NET Framework 4 y versiones anteriores utilizaban solo el algoritmo de Quicksort. Quicksort identifica comparadores no válidos en algunas situaciones en las que la operación de ordenación produzca una excepción de IndexOutOfRangeException , y produce una excepción de ArgumentException al llamador. A partir de .NET Framework 4.5, es posible que ordenar las operaciones que produjo previamente ArgumentException no producirá una excepción, porque los algoritmos de ordenación y de 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 muestran la sobrecarga del método genérico Sort<T>(T[], IComparer<T>) y la sobrecarga del método genérico BinarySearch<T>(T[], T, IComparer<T>).

En el ejemplo de código se define un comparador alternativo para las cadenas, denominado ReverseCompare, que implementa la interfaz genérica IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). El comparador llama al método CompareTo(String), invirtiendo el orden de los términos de la comparación para que las cadenas se ordenen de mayor a menor, y no de menor a mayor.

Se muestra la matriz, se ordena y se vuelve a mostrar. Es necesario ordenar las matrices para utilizar el método BinarySearch.

NotaNota

Las llamadas a los métodos genéricos Sort<T>(T[], IComparer<T>) y BinarySearch<T>(T[], T, IComparer<T>) no presentan ninguna diferencia con respecto a las llamadas a sus homólogos no genéricos puesto que Visual Basic, C# y C++ deducen el tipo del parámetro de tipo genérico a partir del tipo del primer argumento. Si utiliza Ildasm.exe (Desensamblador de IL) para examinar el lenguaje intermedio de Microsoft (MSIL), puede ver que se llama a los métodos genéricos.

A continuación, se utiliza la sobrecarga del método genérico BinarySearch<T>(T[], T, IComparer<T>) para buscar dos cadenas, una que no está en la matriz y otra que sí está. La matriz y el valor devuelto del método BinarySearch<T>(T[], T, IComparer<T>) se pasan al método genérico ShowWhere, que muestra el valor del índice cuando se encuentra la cadena o, de lo contrario, los elementos entre los que se tendría que encontrar la cadena si estuviera en la matriz. El índice es negativo si la cadena no está en la matriz, de modo que el método ShowWhere toma un 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 buscada.


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.
 */


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft