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)

 

Veröffentlicht: Oktober 2016

Sortiert die Elemente in einem Bereich von Elementen in einem eindimensionalen Array mithilfe der IComparable-Implementierung jedes Elements des Array.

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

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

Parameter

array
Type: System.Array

Das zu sortierende eindimensionale Array.

index
Type: System.Int32

Der Startindex des zu sortierenden Bereichs.

length
Type: System.Int32

Die Anzahl der Elemente im zu sortierenden Bereich.

Exception Condition
ArgumentNullException

array ist null.

RankException

array ist mehrdimensional.

ArgumentOutOfRangeException

index ist kleiner als die untere array-Grenze.

- oder -

length ist kleiner als Null.

ArgumentException

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

InvalidOperationException

In einem oder mehreren Elementen in array ist die IComparable-Schnittstelle nicht implementiert.

Jedes Element innerhalb des angegebenen Bereichs von Elementen in array implementieren müssen die IComparable 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, wobei n ist length.

Im folgenden Codebeispiel wird veranschaulicht, wie zum Sortieren der Werte in einer Array mithilfe des Standardcomparers und einem benutzerdefinierten Vergleich, der die Sortierreihenfolge umgekehrt. Beachten Sie, die das Ergebnis, abhängig von der aktuellen variieren kann 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    

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