Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Array.Sort<TKey, TValue>-Methode: (TKey[], TValue[], Int32, Int32)

 

Veröffentlicht: Oktober 2016

Sortiert einen Bereich von Elementen in einem Paar von Array-Objekten (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die Implementierung der generischen IComparable<T>-Schnittstelle jedes Schlüssels.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parameter

keys
Type: TKey[]

Das eindimensionale nullbasierte Array mit den zu sortierenden Schlüsseln.

items
Type: TValue[]

Das eindimensionale nullbasierte Array, das die den Schlüsseln in keys entsprechenden Elemente enthält, oder null, um nur keys zu sortieren.

index
Type: System.Int32

Der Startindex des zu sortierenden Bereichs.

length
Type: System.Int32

Die Anzahl der Elemente im zu sortierenden Bereich.

Typparameter

TKey

Der Typ der Elemente des Schlüsselarrays.

TValue

Der Typ der Elemente des Elementarrays.

Exception Condition
ArgumentNullException

keys ist null.

ArgumentOutOfRangeException

index ist kleiner als die Untergrenze von keys.

- oder -

length ist kleiner als Null.

ArgumentException

items ist nicht null, und die Untergrenze von keys entspricht nicht der Untergrenze von items.

- oder -

items ist nicht null, und die Länge von keys ist größer als die Länge von items.

- oder -

index und length geben keinen gültigen Bereich im keysArray an.

- oder -

items ist nicht null, und index und length geben keinen gültigen Bereich im itemsArray an.

InvalidOperationException

In einem oder mehreren Elementen im keysArray ist die generische IComparable<T>-Schnittstelle nicht implementiert.

Jeder Schlüssel in der keysArray verfügt über ein entsprechendes Element in der itemsArray. Wenn ein Schlüssel positioniert wird, bei der Sortierung, des entsprechenden Elements in der itemsArray auf ähnliche Weise neu angeordnet. Aus diesem Grund die itemsArray sortiert wird, gemäß der Anordnung der entsprechenden Schlüssel in der keysArray.

Jeder Schlüssel innerhalb des angegebenen Bereichs von Elementen in der keysArray implementieren müssen die IComparable<T> generischen Schnittstelle, die mit jedem anderen Schlüssel verglichen werden kann.

Sie können sortieren, wenn es mehr Elemente als Schlüssel sind, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert. Wenn es sich um mehrere Schlüssel als Elemente können nicht sortiert werden; Dies löst dies einen ArgumentException.

Wenn die Sortierung nicht erfolgreich abgeschlossen wird, sind die Ergebnisse nicht definiert.

Diese Methode verwendet die introspective Sortieralgorithmus (Introsort) wie folgt aus:

  • Wenn die Partitionsgröße Elemente weniger als 16 ist, verwendet eine insertion sort Algorithmus.

  • Überschreitet die Anzahl der Partitionen 2 * LogN, wobei N ist der Bereich des Eingabearrays, verwendet er eine Heapsort Algorithmus.

  • Andernfalls wird eine Quicksort Algorithmus.

Diese Implementierung führt eine instabile Sortierung aus. Das heißt, dass die Reihenfolge gleicher Elemente unter Umständen nicht beibehalten werden kann. Im Gegensatz dazu behält eine stabile Sortierung die Reihenfolge der Elemente, die gleich sind.

Für Arrays, die mithilfe von Algorithmen Heapsort und Quicksort im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Protokoll n) Vorgang, wobei n ist length.

Das folgende Codebeispiel veranschaulicht dieSort<TKey, TValue>(TKey[], TValue[]), Sort<TKey, TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32), und Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Überladungen der generischen Methode, für die Sortierung von Paaren von Arrays, die Schlüssel und Werte darstellen.

Im Codebeispiel wird einen alternativer Vergleich für Zeichenfolgen, die mit dem Namen definiert ReverseCompare, implementiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle. Der Vergleich ruft die CompareTo(String) -Methode, die Reihenfolge der verglichenen Elemente umkehren, sodass Zeichenfolgen hoch zu niedrig anstelle von niedrig zu hoch sortieren.

Das Codebeispiel erstellt und zeigt ein Array von Dinosauriernamen (Schlüssel) und ein Array von ganzen Zahlen, die die maximale Länge der einzelnen Dinosaurier in Metern (Werten) darstellt. Die Arrays werden dann sortiert und mehrmals angezeigt:

System_CAPS_noteHinweis

Die Aufrufe an den generischen Methoden suchen nicht anders als die Aufrufe an ihre nicht generischen Entsprechungen, da Visual Basic, c# und C++ den Typ des generischen Typparameters vom Typ der ersten beiden Argumente abgeleitet werden. Bei Verwendung der Ildasm.exe (IL Disassembler) um die Microsoft intermediate Language (MSIL) zu untersuchen, sehen Sie, dass die generischen Methoden aufgerufen werden.

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

Universelle Windows-Plattform
Verfügbar seit 10
.NET Framework
Verfügbar seit 2.0
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Zurück zum Anfang
Anzeigen: