Sort Methode (Array, Int32, Int32, IComparer)
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-Methode (Array, Int32, Int32, IComparer)

 

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe dem angegebenen IComparer.

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

public static void Sort(
	Array array,
	int index,
	int length,
	IComparer comparer
)

Parameter

array

Das zu sortierende eindimensionale Array.

index

Der Startindex des zu sortierenden Bereichs.

length

Die Anzahl der Elemente im zu sortierenden Bereich.

comparer

Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll.

- oder -

null, wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll.

Exception Condition
ArgumentNullException

array ist null.

RankException

array ist mehrdimensional.

ArgumentOutOfRangeException

index ist kleiner als die untere Grenze von array.

- oder -

length ist kleiner als Null.

ArgumentException

index und length geben keinen gültigen Bereich in array an.

- oder -

Die Implementierung von comparer hat während der Sortierung einen Fehler verursacht. comparer kann z. B. möglicherweise nicht 0 zurückgeben, wenn ein Element mit sich selbst verglichen wird.

InvalidOperationException

comparer ist null, und mindestens ein Element in array implementiert die IComparable-Schnittstelle nicht.

Wenn comparer ist null, jedes Element innerhalb des angegebenen Bereichs von Elementen in array implementieren, müssen die IComparable Schnittstelle kann Vergleiche mit allen anderen Elementen in array.

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

.NET Framework enthält vordefinierte IComparer Implementierungen in der folgenden Tabelle aufgeführt.

Implementierung

Beschreibung

System.Collections.CaseInsensitiveComparer

Vergleicht zwei Objekte, aber der Zeichenfolgen zwischen Groß-und Kleinschreibung ausführt.

Comparer.Default

Vergleicht zwei Objekte mithilfe der Sortierkonventionen der aktuellen Kultur.

Comparer.DefaultInvariant

Vergleicht zwei Objekte mithilfe der Sortierkonventionen der invarianten Kultur.

Comparer<T>.Default

Vergleicht zwei Objekte des Typs T mithilfe der Standard-Sortierreihenfolge für den Typ.

Sie können auch benutzerdefinierte Vergleiche unterstützen, durch eine eigene Instanz bereitgestellt IComparer -Implementierung, die die comparer Parameter.Im Beispiel wird dieses durch die Definition einer ReverseComparer -Klasse, die die Standardsortierreihenfolge für kehrt Instanzen eines Typs und Zeichenfolgenvergleich ausführt.

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

  • Wenn die Größe der Partition weniger als 16 Elemente beträgt, wird ein Einfügesortierung Algorithmus verwendet.

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

  • Andernfalls wird ein 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, bei.

Für Arrays, die mit den Algorithmen Heapsort und wenden die Schnellsortierung im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Protokoll n)-Vorgang, wobei n ist length.

Hinweise zu Aufrufern:

Die .NET Framework 4 und früheren Versionen verwendet den Quicksort-Algorithmus.QuickSort identifiziert ungültige Comparer in einigen Situationen, in denen der Sortiervorgang löst, eine 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 keine Ausnahme auslöst, eine Ausnahme aus, da die Einfügung sortieren und Heapsort Algorithmen ein ungültiger Vergleich nicht erkennen.Zum größten Teil auf Arrays mit weniger als 16 Elemente angewendet wird.

Das folgende Codebeispiel veranschaulicht das Sortieren der Werte in einer Array mithilfe des Standardvergleichs sowie eines benutzerdefinierten Vergleichs, der die Sortierreihenfolge umkehrt.Hinweis, der das Ergebnis, je nach der aktuellen variieren CultureInfo.

using System;
using System.Collections;

public class ReverseComparer : IComparer  
{
   // Call CaseInsensitiveComparer.Compare with the parameters reversed.
   public int Compare(Object x, Object y)  
   {
       return (new CaseInsensitiveComparer()).Compare(y, x );
   }
}

public class Example 
{
   public static void Main()  
   {
      // Create and initialize a new array. 
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps", 
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();

      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);

      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

      // Sort a section of the array using the reverse case-insensitive comparer.
      Array.Sort(words, 1, 3, revComparer);
      Console.WriteLine( "After sorting elements 1-3 by using the reverse case-insensitive comparer:");
      DisplayValues(words);

      // Sort the entire array using the default comparer.
      Array.Sort(words);
      Console.WriteLine( "After sorting the entire array by using the default comparer:");
      DisplayValues(words);

      // Sort the entire array by using the reverse case-insensitive comparer.
      Array.Sort(words, revComparer);
      Console.WriteLine( "After sorting the entire array using the reverse case-insensitive comparer:");
      DisplayValues(words);
   }

   public static void DisplayValues(String[] arr)  
   {
      for ( int i = arr.GetLowerBound(0); i <= arr.GetUpperBound(0);
            i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arr[i] );
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    The original order of elements in the array:
//       [0] : The
//       [1] : QUICK
//       [2] : BROWN
//       [3] : FOX
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting elements 1-3 by using the default comparer:
//       [0] : The
//       [1] : BROWN
//       [2] : FOX
//       [3] : QUICK
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting elements 1-3 by using the reverse case-insensitive comparer:
//       [0] : The
//       [1] : QUICK
//       [2] : FOX
//       [3] : BROWN
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//    
//    After sorting the entire array by using the default comparer:
//       [0] : BROWN
//       [1] : dog
//       [2] : FOX
//       [3] : jumps
//       [4] : lazy
//       [5] : over
//       [6] : QUICK
//       [7] : the
//       [8] : The
//    
//    After sorting the entire array using the reverse case-insensitive comparer:
//       [0] : the
//       [1] : The
//       [2] : QUICK
//       [3] : over
//       [4] : lazy
//       [5] : jumps
//       [6] : FOX
//       [7] : dog
//       [8] : BROWN    

Universal Windows Platform
Verfügbar seit 4.5
.NET Framework
Verfügbar seit 1.1
Portable Class Library
Unterstützt in: portable .NET platforms
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:
© 2016 Microsoft