(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Array.Sort-Methode (Array, IComparer)

Sortiert die Elemente in einem eindimensionalen Array mithilfe des angegebenen IComparer.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)
public static void Sort(
	Array array,
	IComparer comparer
)

Parameter

array
Typ: System.Array
Das zu sortierende eindimensionale Array.
comparer
Typ: System.Collections.IComparer
Die IComparer-Implementierung, die beim Vergleich von Elementen verwendet werden soll.
- oder -
null , wenn die IComparable-Implementierung des jeweiligen Elements verwendet werden soll.
AusnahmeBedingung
ArgumentNullException

array ist null.

RankException

array ist mehrdimensional.

InvalidOperationException

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

ArgumentException

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.

Wenn comparernull ist, muss jedes Element von array die IComparable-Schnittstelle implementieren, damit es mit jedem anderen Element von array verglichen werden kann.

Wenn der Sortiervorgang nicht erfolgreich abgeschlossen werden kann, ist das Ergebnis undefiniert.

Diese Methode verwendet den introspektiven Algorithmus der Sortierung (introsort), wie folgt:

  • Wenn die Partitionsgröße weniger als 16 Elemente ist, verwendet sie einen Einfügungssortierung Algorithmus.

  • Wenn die Anzahl der Partitionen 2 überschreitet * protokollieren Sie N, wobei N der Bereich des Eingabearrays ist, es verwendet einen Heapsort Algorithmus.

  • Andernfalls verwendet sie einen Quicksort Algorithmus.

Diese Implementierung führt eine instabile Sortierung durch, d. h., bei zwei gleichen Elementen wird die Reihenfolge möglicherweise nicht beibehalten. Bei einer stabilen Sortierung wird im Gegensatz dazu die Reihenfolge von gleichen Elementen beibehalten.

Für Arrays, die sortiert werden, indem das Heapsort verwendet und Quicksort-Algorithmen, im ungünstigsten Fall, diese Methode ein Vorgang zu O (n Protokoll n), wobei n von Lengtharray ist.

Hinweise zu Aufrufern

. .NET Framework 4 und früheren Versionen wurde nur des QuickSort-Algorithmus. Quicksort identifiziert ungültige Vergleiche in einigen Situationen, in denen der Sortierung eine IndexOutOfRangeException Ausnahme auslöst, und löst eine ArgumentException Ausnahme zum Aufrufer aus. Ab .NET Framework 4.5, ist es möglich, dass Sortiervorgänge, die zuvor ArgumentException auslösen, keine Ausnahme ausgelöst, da die Einfüge- Sortier- und heapsortalgorithmen keinen ungültigen Vergleich erkennen. In den meisten Fällen wird dies auf Arrays mit weniger als 16 Elemente zu.

Im folgenden Codebeispiel wird das Sortieren der Werte in einem Array mithilfe des Standardcomparers und eines benutzerdefinierten Comparers veranschaulicht, der die Sortierreihenfolge umkehrt. Beachten Sie, dass das Ergebnis in Abhängigkeit von der aktuellen CultureInfo variieren kann.


using System;
using System.Collections;

public class SamplesArray  {

   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }

   }

   public static void Main()  {

      // Creates and initializes a new Array and a new custom comparer.
      String[] myArr = { "The", "QUICK", "BROWN", "FOX", "jumps", "over", "the", "lazy", "dog" };
      IComparer myComparer = new myReverserClass();

      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintIndexAndValues( myArr );

      // Sorts a section of the Array using the default comparer.
      Array.Sort( myArr, 1, 3 );
      Console.WriteLine( "After sorting a section of the Array using the default comparer:" );
      PrintIndexAndValues( myArr );

      // Sorts a section of the Array using the reverse case-insensitive comparer.
      Array.Sort( myArr, 1, 3, myComparer );
      Console.WriteLine( "After sorting a section of the Array using the reverse case-insensitive comparer:" );
      PrintIndexAndValues( myArr );

      // Sorts the entire Array using the default comparer.
      Array.Sort( myArr );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintIndexAndValues( myArr );

      // Sorts the entire Array using the reverse case-insensitive comparer.
      Array.Sort( myArr, myComparer );
      Console.WriteLine( "After sorting the entire Array using the reverse case-insensitive comparer:" );
      PrintIndexAndValues( myArr );

   }

   public static void PrintIndexAndValues( String[] myArr )  {
      for ( int i = 0; i < myArr.Length; i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, myArr[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   [0] : The
   [1] : QUICK
   [2] : BROWN
   [3] : FOX
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array using the default comparer:
   [0] : The
   [1] : BROWN
   [2] : FOX
   [3] : QUICK
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

After sorting a section of the Array 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 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

*/



.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.