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<TKey, TValue>(TKey[], TValue[])

 

Data di pubblicazione: ottobre 2016

Ordina una coppia di oggetti Array (uno contenente le chiavi e l'altro contenente gli elementi corrispondenti) in base alle chiavi del primo oggetto Array usando l'implementazione dell'interfaccia generica IComparable<T> di ogni chiave.

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

public static void Sort<TKey, TValue>(
	TKey[] keys,
	TValue[] items
)

Parametri

keys
Type: TKey[]

Oggetto Array unidimensionale in base zero che contiene le chiavi da ordinare.

items
Type: TValue[]

Oggetto unidimensionale in base zero Array che contiene gli elementi che corrispondono alle chiavi in keys oppure null per ordinare solo keys.

Parametri tipo

TKey

Tipo degli elementi della matrice delle chiavi.

TValue

Tipo degli elementi della matrice degli elementi.

Exception Condition
ArgumentNullException

keys è null.

ArgumentException

items non è null e il limite inferiore di keys non corrisponde al limite inferiore di items.

-oppure-

items non è null e la lunghezza di keys è maggiore della lunghezza di items.

InvalidOperationException

Uno o più elementi nell'oggetto Array di keys non implementano l'interfaccia generica IComparable<T>.

Ogni chiave di keysArray dispone di un elemento corrispondente itemsArray. Quando una chiave viene riposizionata durante l'ordinamento, l'elemento corrispondente nella itemsArray viene riposizionato in modo analogo. Pertanto, il itemsArray viene ordinato in base a disposizione delle chiavi corrispondenti nel keysArray.

Ogni chiave di keysArray deve implementare il IComparable<T> interfaccia generica per essere in grado di eseguire confronti con ogni altra chiave.

È possibile ordinare se sono presenti più elementi di chiavi, ma non saranno ordinati gli elementi che non dispongono di alcuna chiave corrispondente. Se sono presenti più chiavi di elementi; non è possibile ordinare in caso contrario viene generata unaArgumentException.

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.

L'esempio di codice seguente illustra il Sort<TKey, TValue>(TKey[], TValue[]), Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32), e Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload di metodo generico, per l'ordinamento di coppie di matrici che rappresentano le chiavi e valori.

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.

L'esempio di codice crea e visualizza una matrice di nomi di dinosauro (chiavi) e una matrice di interi che rappresenta la lunghezza massima di ciascun dinosauro espressa in metri (valori). Le matrici vengono ordinate e visualizzate più volte:

System_CAPS_noteNota

Le chiamate ai 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 dei primi due argomenti. Se si utilizza il Ildasm.exe (IL Disassembler) per esaminare il Microsoft intermediate language (MSIL), si noterà che vengono chiamati i metodi generici.

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 = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */

Universal Windows Platform
Disponibile da 10
.NET Framework
Disponibile da 2.0
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Torna all'inizio
Mostra: