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 Array.Sort<T>(T[], IComparer<T>)

 

Data di pubblicazione: ottobre 2016

Ordina gli elementi in un oggetto Array usando l'interfaccia generica IComparer<T> specificata.

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

public static void Sort<T>(
	T[] array,
	IComparer<T> comparer
)

Parametri

array
Type: T[]

Oggetto Array unidimensionale in base zero da ordinare.

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

Implementazione dell'interfaccia generica IComparer<T> da usare per il confronto fra gli elementi oppure null per usare l'implementazione dell'interfaccia generica IComparable<T> di ciascun elemento.

Parametri tipo

T

Tipo degli elementi della matrice.

Exception Condition
ArgumentNullException

array è null.

InvalidOperationException

comparer è null e uno o più elementi in array non implementano l'interfaccia generica di IComparable<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 è null, ogni elemento di array deve implementare il IComparable<T> interfaccia generica per essere in grado di eseguire confronti con ogni altro elemento array.

Se l'ordinamento non è stato completato correttamente, i risultati sono indefiniti.

Questo metodo utilizza l'algoritmo di ordinamento interiorizzata (introsort) come segue:

  • Se la dimensione della partizione è inferiore a 16 elementi, viene utilizzato un insertion sort algoritmo.

  • 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 Quicksort algoritmo.

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.

Per le matrici vengono ordinate utilizzando gli algoritmi Heapsort e Quicksort, nel peggiore dei casi, questo metodo è un'operazione O (n log n) operazione, in cui n è il Length di array.

Note per i chiamanti:

Il .NET Framework 4 e versioni precedenti utilizzato solo l'algoritmo Quicksort. QuickSort identifica gli operatori di confronto non validi in alcune situazioni in cui l'operazione di ordinamento genera una IndexOutOfRangeException eccezione e genera un ArgumentException eccezione al chiamante. A partire dal .NET Framework 4.5, è possibile che le operazioni di ordinamento che in precedenza ha generato ArgumentException non genererà un'eccezione, poiché gli algoritmi di ordinamento e heapsort di inserimento non viene rilevano un operatore di confronto non valido. La maggior parte, si applica alle matrici con un massimo di 16 elementi.

L'esempio di codice seguente illustra il Sort<T>(T[], IComparer<T>) overload del metodo generico e BinarySearch<T>(T[], T, IComparer<T>) overload del metodo generico.

L'esempio di codice definisce un operatore di confronto alternativo per le stringhe, denominato ReverseCompare, che implementa il IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) dell'interfaccia generica. Operatore di confronto chiama il CompareTo(String) metodo, invertendo l'ordine dei termini del confronto in modo che l'ordinamento delle stringhe alto verso il basso, anziché basso verso l'alto.

La matrice è visualizzata, ordinata e visualizzata di nuovo. Le matrici devono essere ordinate per utilizzare il BinarySearch<T> metodo.

System_CAPS_noteNota

Le chiamate al Sort<T>(T[], IComparer<T>) e BinarySearch<T>(T[], T, IComparer<T>) metodi generici non presenta alcuna differenza dalle chiamate alle controparti non generiche, perché Visual Basic, c# e C++ dedurre il tipo di parametro di tipo generico dal tipo del primo argomento. Se si utilizza il Ildasm.exe (IL Disassembler) per esaminare il Microsoft intermediate language (MSIL), si noterà che vengono chiamati i metodi generici.

Il BinarySearch<T>(T[], T, IComparer<T>) overload del metodo generico viene quindi utilizzato per eseguire la ricerca di due stringhe, uno che non si trova la matrice e uno che. La matrice e il valore restituito del BinarySearch<T>(T[], T, IComparer<T>) metodo vengono passati al ShowWhere metodo generico, che viene visualizzato il valore di indice se la stringa viene trovata, e in caso contrario gli elementi della stringa di ricerca sarebbe compresa se fosse nella matrice. L'indice è negativo se la stringa non è inclusa nella matrice, pertanto la ShowWhere metodo accetta il complemento bit per bit (il ~ operatore in c# e Visual C++, Xor -1 in Visual Basic) per ottenere l'indice del primo elemento nell'elenco di dimensioni maggiore rispetto alla stringa di ricerca.

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

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: