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

List<T>.Sort-Methode: (Int32, Int32, IComparer<T>)

 

Veröffentlicht: Juli 2016

Sortiert die Elemente in einem Bereich von Elementen in der List<T> mithilfe des angegebenen Vergleichs.

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

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

Parameter

index
Type: System.Int32

Der nullbasierte Startindex des zu sortierenden Bereichs.

count
Type: System.Int32

Die Länge des zu sortierenden Bereichs.

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

Die IComparer<T>-Implementierung, die beim Vergleichen von Elementen verwendet werden soll, oder null, wenn der Standardvergleich Comparer<T>.Default verwendet werden soll.

Exception Condition
ArgumentOutOfRangeException

index ist kleiner als 0.

- oder -

count ist kleiner als 0.

ArgumentException

index und count geben keinen gültigen Bereich in der List<T> an.

- oder -

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.

InvalidOperationException

comparer ist null, und der Standardcomparer Comparer<T>.Default kann die Implementierung der generischen IComparable<T>-Schnittstelle oder der IComparable-Schnittstelle für den Typ T nicht finden.

Wenn comparer angegeben wird, werden die Elemente der List<T> sortiert sind, unter Verwendung des angegebenen IComparer<T> Implementierung.

Wenn comparer ist null, die standardmäßige Vergleichsfunktion Comparer<T>.Default überprüft, ob der Typ T implementiert die IComparable<T> generische Schnittstelle und, dass diese Implementierung verwendet, sofern verfügbar. Wenn dies nicht der Fall ist, Comparer<T>.Default überprüft, ob der Typ T implementiert die IComparable Schnittstelle. Wenn Typ T implementiert nicht die beiden Schnittstellen Comparer<T>.Default löst eine InvalidOperationException.

Diese Methode verwendet Array.Sort, den gilt der introspective Sortierreihenfolge wie folgt:

  • Wenn die Partition weniger als 16 Elemente besitzt, wird ein Insertionsort Algorithmus angewandt.

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

  • Andernfalls verwendet es einen 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.

Im Durchschnitt ist diese Methode eine O (n Protokoll n)-Vorgang, in dem n ist Count; im schlimmsten Fall ist es eine O (n ^ 2) Vorgang.

Das folgende Beispiel veranschaulicht die Sort(Int32, Int32, IComparer<T>) -methodenüberladung und die BinarySearch(Int32, Int32, T, IComparer<T>) methodenüberladung.

Im Beispiel wird einen alternativen Vergleich für DinoCompare implementiert-Zeichenfolgen definiert die IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) generische Schnittstelle. Der Vergleich funktioniert wie folgt: zunächst der verglichenen Elemente getestet werden null, und ein null-Verweis als kleiner als ein Wert ungleich Null behandelt wird. Zweitens die Zeichenfolgenlängen verglichen werden, und die Zeichenfolge längere ist als größer werden. Wenn die Länge gleich sind, wird im dritten gewöhnliche Zeichenfolgenvergleich verwendet.

Ein List<T> von Zeichenfolgen erstellt und mit den Namen der fünf pflanzenfressenden Dinosauriern und drei zur Dinosaurier aufgefüllt wird. In jedem von zwei Gruppen sind die Namen nicht in der Sortierreihenfolge vor. Die Liste wird angezeigt, die Gruppe der Pflanzenfresser wird mit dem alternativen Vergleich sortiert und die Liste wird erneut angezeigt.

Die BinarySearch(Int32, Int32, T, IComparer<T>) methodenüberladung wird dann verwendet, um nur die Gruppe der Pflanzenfresser "Brachiosaurus" suchen. Die Zeichenfolge nicht gefunden wird, und das bitweise Komplement (der ~-Operator in c# und Visual C++ Xor -1 in Visual Basic) für die zurückgegebene negative Zahl der BinarySearch(Int32, Int32, T, IComparer<T>) Methode dient als Index zum Einfügen der neuen Zeichenfolge.

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

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: