Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo List<T>.Sort (IComparer<T>)

 

Data di pubblicazione: ottobre 2016

Ordina gli elementi dell'intero List<T> usando l'operatore di confronto specificato.

Spazio dei nomi:   System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

public void Sort(
	IComparer<T> comparer
)

Parametri

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

Implementazione IComparer<T> da usare durante il confronto di elementi oppure null per usare la proprietà Comparer<T>.Default dell'operatore di confronto.

Exception Condition
InvalidOperationException

comparer è null e l'operatore di confronto predefinito Comparer<T>.Default non riesce a trovare l'implementazione dell'interfaccia generica IComparable<T> o l'interfaccia IComparable per il tipo T.

ArgumentException

L'implementazione di comparer ha causato un errore durante l'ordinamento. Ad esempio, comparer potrebbe non restituire 0 quando si confronta un elemento con se stesso.

Se comparer viene fornito, gli elementi del List<T> vengono ordinati usando il valore IComparer<T> implementazione.

Se comparer è null, l'operatore di confronto Comparer<T>.Default verifica se il tipo T implementa il IComparable<T> interfaccia generica e utilizza tale implementazione, se disponibile. In caso contrario, Comparer<T>.Default verifica se il tipo T implementa il IComparable interfaccia. Se tipo T non implementa l'interfaccia Comparer<T>.Default Genera un InvalidOperationException.

Questo metodo utilizza il Array.Sort metodo, che applica l'ordinamento interiorizzata come indicato di seguito:

  • Se la dimensione della partizione è inferiore a 16 elementi, viene utilizzato un algoritmo di ordinamento di inserimento.

  • Se il numero di partizioni superiore a 2 * LogN, dove N è l'intervallo della matrice di input, viene utilizzato un algoritmo Heapsort.

  • In caso contrario, viene utilizzato un algoritmo Quicksort.

Questa implementazione viene eseguito un ordinamento instabile; vale a dire se due elementi sono uguali, l'ordine potrebbe non essere mantenuto. Al contrario, un ordinamento stabile mantiene l'ordine degli elementi che sono uguali.

In Media, questo metodo è un'operazione O (n log n) operazione, in cui n è Count; nel peggiore dei casi è un'operazione O (n ^ 2) operazione.

Nell'esempio seguente viene illustrato il Sort(IComparer<T>) overload del metodo e BinarySearch(T, IComparer<T>) overload del metodo.

L'esempio definisce un operatore di confronto alternativo per le stringhe denominato DinoCompare, che implementa il IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) dell'interfaccia generica. L'operatore di confronto funziona nel modo seguente: in primo luogo, i termini di confronto vengono verificati i null, e un riferimento null viene considerato minore rispetto a un valore non null. In secondo luogo, vengono confrontate le lunghezze di stringa e la stringa più lunga è considerata maggiore. In terzo luogo, se le lunghezze sono uguali, viene utilizzato confronto tra stringhe normali.

Oggetto List<T> di stringhe viene creato e popolato con quattro stringhe, senza nessun ordine particolare. L'elenco viene visualizzato, ordinato utilizzando l'operatore di confronto alternativo e visualizzata nuovamente.

Il BinarySearch(T, IComparer<T>) overload del metodo viene quindi utilizzato per cercare le diverse stringhe sono non in elenco, utilizzando l'operatore di confronto alternativo. Il Insert metodo viene utilizzato per inserire le stringhe. Questi due metodi si trovano nella funzione denominata SearchAndInsert, insieme al codice per utilizzare il complemento bit per bit (il ~ operatore in c# e Visual C++, Xor -1 in Visual Basic) del numero negativo restituito da BinarySearch(T, IComparer<T>) e utilizzarlo come indice per l'inserimento della nuova stringa.

using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(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 class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list, 
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

        int index = list.BinarySearch(insert, dc);

        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: