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 (Int32, Int32, IComparer<T>)

 

Ordina gli elementi di un intervallo di elementi di List<T> usando l'operatore di confronto specificato.

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

public void Sort(
	int index,
	int count,
	IComparer<T> comparer
)

Parametri

index
Type: System.Int32

Indice iniziale in base zero dell'intervallo da ordinare.

count
Type: System.Int32

Lunghezza dell'intervallo da ordinare.

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
ArgumentOutOfRangeException

index è minore di 0.

-oppure-

count è minore di 0.

ArgumentException

index e count non specificano un intervallo valido in List<T>.

-oppure-

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.

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.

Se comparer viene fornito, gli elementi del List<T> vengono ordinati usando l'oggetto 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 Array.Sort, che si 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 Heapsort algoritmo.

  • In caso contrario, viene utilizzato un algoritmo di Quicksort.

Questa implementazione esegue un ordinamento instabile; ovvero, se due elementi sono uguali, l'ordine potrebbe non essere mantenuta. 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 si tratta di un'operazione O (n ^ 2) operazione.

Nell'esempio seguente viene illustrato il Sort(Int32, Int32, IComparer<T>) overload del metodo e BinarySearch(Int32, Int32, 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: prima di tutto, i termini di confronto da testare per 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 il confronto di stringa normali.

Oggetto List<T> di stringhe viene creata e popolata con i nomi dei cinque dinosauri erbivori e tre dinosauri carnivori. All'interno di ognuno dei due gruppi, i nomi non sono in alcun ordinamento particolare. Viene visualizzato l'elenco, l'intervallo di erbivori viene ordinato utilizzando l'operatore di confronto alternativo e viene nuovamente visualizzato l'elenco.

Il BinarySearch(Int32, Int32, T, IComparer<T>) overload del metodo viene quindi utilizzato per la ricerca solo l'intervallo di erbivori "Brachiosaurus". La stringa non viene trovata e il complemento bit per bit (il ~ (operatore) in c# e Visual C++, Xor -1 in Visual Basic) del numero negativo restituito dal BinarySearch(Int32, Int32, T, IComparer<T>) metodo viene utilizzato 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("Parasauralophus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Galimimus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Oviraptor");
        dinosaurs.Add("Tyrannosaurus");

        int herbivores = 5;
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort a range with the alternate comparer:");
        dinosaurs.Sort(0, herbivores, dc);
        Display(dinosaurs);

        Console.WriteLine("\nBinarySearch a range and Insert \"{0}\":",
            "Brachiosaurus");

        int index = dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc);

        if (index < 0)
        {
            dinosaurs.Insert(~index, "Brachiosaurus");
            herbivores++;
        }

        Display(dinosaurs);
    }

    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
Parasauralophus
Amargasaurus
Galimimus
Mamenchisaurus
Deinonychus
Oviraptor
Tyrannosaurus

Sort a range with the alternate comparer:

Galimimus
Amargasaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus

BinarySearch a range and Insert "Brachiosaurus":

Galimimus
Amargasaurus
Brachiosaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus
 */

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: