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, Array)

 

Veröffentlicht: Oktober 2016

Sortiert ein Paar eindimensionaler Array-Objekte (das eine enthält die Schlüssel und das andere die entsprechenden Werte) nach den Schlüsseln im ersten Array und verwendet dabei die IComparable-Implementierung der einzelnen Schlüssel.

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

public static void Sort(
	Array keys,
	Array items
)

Parameter

keys
Type: System.Array

Das eindimensionale Array mit den zu sortierenden Schlüsseln.

items
Type: System.Array

Das eindimensionale Array mit den Elementen, die den jeweiligen Schlüsseln im keysArray entsprechen.

- oder -

null, wenn nur das keysArray sortiert werden soll.

Exception Condition
ArgumentNullException

keys ist null.

RankException

Das keysArray ist mehrdimensional.

- oder -

Das itemsArray ist mehrdimensional.

ArgumentException

items ist nicht null, und die Länge von keys ist größer als die Länge von items.

InvalidOperationException

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

Jeder Schlüssel in der keysArray verfügt über ein entsprechendes Element in der itemsArray. Wenn ein Schlüssel positioniert wird, bei der Sortierung, des entsprechenden Elements in der itemsArray wird neu positioniert. Aus diesem Grund die itemsArray sortiert wird, gemäß der Anordnung der entsprechenden Schlüssel in der keysArray.

Jeder Schlüssel in der keysArray implementieren muss die IComparable Schnittstelle, um mit jedem anderen Schlüssel verglichen werden kann.

Sie können sortieren, wenn mehr Elemente als Schlüssel vorhanden sind, aber die Elemente, die ohne entsprechenden Schlüssel werden nicht sortiert. Wenn mehr Schlüssel als Elemente vorhanden sind, können nicht sortiert werden; Dies löst dies eine ArgumentException.

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

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

  • Wenn die Größe der Partition weniger als 16 Elemente ist, verwendet es einen insertion sort Algorithmus.

  • Überschreitet 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.

Für Arrays, die mit dem Heapsort und Quicksort-Algorithmus, im schlimmsten Fall sortiert sind, ist diese Methode eine O (n Protokoll n)-Vorgang, in dem n ist der Length der keys.

Im folgende Beispiel wird das Sortieren von zwei verknüpften Arrays, wobei das erste Array enthält die Schlüssel und das zweite Array enthält die Werte, veranschaulicht. Sortiert erfolgt mithilfe des Standardvergleichs sowie eines benutzerdefinierten Vergleichs, der die Sortierreihenfolge umkehrt. Beachten Sie, das das Ergebnis kann je nach der aktuellen abweichen CultureInfo.

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[] myKeys = { "red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange" };
      String[] myValues = { "strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe" };
      IComparer myComparer = new myReverserClass();

      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintKeysAndValues( myKeys, myValues );

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

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

      // Sorts the entire Array using the default comparer.
      Array.Sort( myKeys, myValues );
      Console.WriteLine( "After sorting the entire Array using the default comparer:" );
      PrintKeysAndValues( myKeys, myValues );

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

   }

   public static void PrintKeysAndValues( String[] myKeys, String[] myValues )  {
      for ( int i = 0; i < myKeys.Length; i++ )  {
         Console.WriteLine( "   {0,-10}: {1}", myKeys[i], myValues[i] );
      }
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

The Array initially contains the following values:
   red       : strawberries
   GREEN     : PEARS
   YELLOW    : LIMES
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the default comparer:
   red       : strawberries
   BLUE      : BERRIES
   GREEN     : PEARS
   YELLOW    : LIMES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting a section of the Array using the reverse case-insensitive comparer:
   red       : strawberries
   YELLOW    : LIMES
   GREEN     : PEARS
   BLUE      : BERRIES
   purple    : grapes
   black     : olives
   orange    : cantaloupe

After sorting the entire Array using the default comparer:
   black     : olives
   BLUE      : BERRIES
   GREEN     : PEARS
   orange    : cantaloupe
   purple    : grapes
   red       : strawberries
   YELLOW    : LIMES

After sorting the entire Array using the reverse case-insensitive comparer:
   YELLOW    : LIMES
   red       : strawberries
   purple    : grapes
   orange    : cantaloupe
   GREEN     : PEARS
   BLUE      : BERRIES
   black     : olives

*/

Universelle Windows-Plattform
Verfügbar seit 10
.NET Framework
Verfügbar seit 1.1
Zurück zum Anfang
Anzeigen: