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<T>-Methode: (T[], IComparer<T>)

 

Veröffentlicht: Oktober 2016

Sortiert die Elemente in einem Array mithilfe der angegebenen generischen IComparer<T>-Schnittstelle.

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

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

Parameter

array
Type: T[]

Das zu sortierende eindimensionale und nullbasierte Array.

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

Die Implementierung der generischen IComparer<T>-Schnittstelle, die für den Vergleich von Elementen verwendet werden soll, oder null, um die Implementierung der generischen IComparable<T>-Schnittstelle der einzelnen Elemente zu verwenden.

Typparameter

T

Der Typ der Elemente des Arrays.

Exception Condition
ArgumentNullException

array ist null.

InvalidOperationException

comparer ist null, und in einem oder mehreren Elementen im array ist die generische IComparable<T>-Schnittstelle nicht implementiert.

ArgumentException

Die Implementierung von comparer hat einen Fehler während der Sortierung verursacht. Beispielsweise gibt comparer beim Vergleichen eines Elements mit sich selbst möglicherweise nicht 0 zurück.

Wenn comparer ist null, jedes Element der array implementieren müssen die IComparable<T> generische Schnittstelle kann Vergleiche mit jedem anderen Element im array.

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, in dem n ist die Length von array.

Hinweise für Aufrufer:

Der .NET Framework 4 und früheren Versionen verwendet nur den Quicksort-Algorithmus. QuickSort identifiziert ungültige Vergleiche in einigen Situationen, in dem der Sortiervorgang löst, ein IndexOutOfRangeException Ausnahme und löst eine ArgumentException Ausnahme an den Aufrufer. Beginnend mit der .NET Framework 4.5, es ist möglich, dass ausgelöst, das zuvor Sortiervorgänge hat ArgumentException Ausnahme nicht ausgelöst, da die Algorithmen einfügen, Sortieren und Heapsort ein ungültiger Vergleich nicht erkennen. Dies gilt meistens, für Arrays mit weniger als 16 Elementen.

Das folgende Codebeispiel veranschaulicht die Sort<T>(T[], IComparer<T>) generischen methodenüberladung und die BinarySearch<T>(T[], T, IComparer<T>) generischen methodenüberladung.

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 Array wird angezeigt, sortiert und erneut angezeigt. Arrays müssen sortiert werden, um mithilfe der BinarySearch<T> Methode.

System_CAPS_noteHinweis

Die Aufrufe an die Sort<T>(T[], IComparer<T>) und BinarySearch<T>(T[], T, IComparer<T>) generische Methoden nicht suchen alle Aufrufe an ihre nicht generischen Entsprechungen unterscheiden, da Visual Basic, c# und C++ den Typ des vom Typ des ersten Arguments der generischen Typparameter 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.

Die BinarySearch<T>(T[], T, IComparer<T>) generischen methodenüberladung wird dann verwendet, um zwei Zeichenfolgen zu suchen, ist eine, die nicht in das Array und eine ist. Das Array und den Rückgabewert der BinarySearch<T>(T[], T, IComparer<T>) an die Methode übergeben werden die ShowWhere generische Methode, die den Indexwert zeigt an, wenn die Zeichenfolge gefunden wird, und andernfalls die Elemente die Suchzeichenfolge fallen würde zwischen wären im Array. Der Index ist negativ, wenn die Zeichenfolge nicht n ist das Array daher die ShowWhere Methode nimmt das bitweise Komplement (die ~ Operator in c# und Visual C++ Xor -1 in Visual Basic) um den Index des ersten Elements in der Liste zu erhalten, die größer ist als die zu suchende Zeichenfolge.

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

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: