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[], Comparison<T>)

 

Publicado: octubre de 2016

Ordena los elementos de una Array usando el Comparison<T> especificado.

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

public static void Sort<T>(
	T[] array,
	Comparison<T> comparison
)

Parámetros

array
Type: T[]

Array unidimensional, basado en cero, que se va a ordenar

comparison
Type: System.Comparison<T>

Comparison<T> que se va a utilizar al comparar elementos.

Parámetros de tipo

T

Tipo de los elementos de la matriz.

Exception Condition
ArgumentNullException

El valor de array es null.

-o-

El valor de comparison es null.

ArgumentException

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

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

Este método utiliza el algoritmo de ordenación introspectivas (introsort) como sigue:

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

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

  • De lo contrario, utiliza un Quicksort algoritmo.

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

Para las matrices que se ordenan utilizando 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 sólo el algoritmo Quicksort. QuickSort identifica comparadores no válidos en algunas situaciones en que se inicia la operación de ordenación un 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á una excepción porque los algoritmos de ordenación y heapsort de inserción no detectan un comparador no válido. En su mayor parte, esto se aplica a las matrices con menos de 16 elementos.

En el ejemplo de código siguiente se muestra el Sort(Comparison<T>) sobrecarga del método.

El ejemplo de código define un método de comparación alternativo para las cadenas, denominado CompareDinosByLength. Este método funciona del siguiente modo: en primer lugar, busca el comparandsarenull, y una referencia nula se considera menor que un valor no null. En segundo lugar, se comparan las longitudes de cadena y la cadena más larga se considera mayor. En tercer lugar, si las longitudes son iguales, se utiliza la comparación de cadenas normales.

Una matriz de cadenas se crean y rellenan con cuatro cadenas, sin ningún orden determinado. La lista también incluye una cadena vacía y una referencia nula. La lista se muestra, se ordena usando un Comparison<T> delegado genérico que representa la CompareDinosByLength (método) y vuelva a aparecer.

using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }

    public static void Main()
    {
        string[] dinosaurs = {
            "Pachycephalosaurus",
            "Amargasaurus",
            "",
            null,
            "Mamenchisaurus",
            "Deinonychus" };
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        Array.Sort(dinosaurs, CompareDinosByLength);
        Display(dinosaurs);

    }

    private static void Display(string[] arr)
    {
        Console.WriteLine();
        foreach( string s in arr )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */

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: