Array.Sort Array.Sort Array.Sort Array.Sort Method

Definice

Seřadí prvky v jednorozměrném poli.Sorts the elements in a one-dimensional array.

Přetížení

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí zadaného IComparer.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Seřadí rozsah prvků ve dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí IComparable implementace každého prvku Array.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Seřadí rozsah prvků ve dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace každého klíče IComparable.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Seřadí prvky v jednorozměrném Array pomocí zadaného IComparer.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Seřadí dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Seřadí dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace každého klíče IComparable.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array) Sort(Array) Sort(Array)

Seřadí prvky v celém jednorozměrném Array pomocí implementace IComparable každého prvku Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Seřadí prvky v celé Array pomocí implementace obecného rozhraní IComparable<T> každého prvku Array.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Seřadí prvky v Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts the elements in an Array using the specified IComparer<T> generic interface.

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Seřadí prvky v Array pomocí zadaného Comparison<T>.Sorts the elements in an Array using the specified Comparison<T>.

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32)

Seřadí prvky v rozsahu prvků Array pomocí implementace obecného rozhraní IComparable<T> pro každý prvek Array.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Seřadí prvky v rozsahu prvků Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Seřadí pár objektů Array (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace obecného rozhraní IComparable<T> pro každý klíč.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Seřadí pár objektů Array (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Seřadí rozsah prvků ve dvojici objektů @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace obecného rozhraní IComparable<T> s každým klíčem.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Seřadí rozsah prvků ve dvojici objektů @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí zadaného IComparer.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

public:
 static void Sort(Array ^ array, int index, int length, System::Collections::IComparer ^ comparer);
public static void Sort (Array array, int index, int length, System.Collections.IComparer comparer);
static member Sort : Array * int * int * System.Collections.IComparer -> unit

Parametry

array
Array Array Array Array

Jednorozměrné Array pro řazení.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Implementace IComparer, která se má použít při porovnávání prvků.The IComparer implementation to use when comparing elements.

-nebo--or- null pro použití implementace IComparable každého prvku.null to use the IComparable implementation of each element.

Výjimky

array je multidimenzionální.array is multidimensional.

index je menší než dolní mez array.index is less than the lower bound of array.

-nebo--or- length je menší než nula.length is less than zero.

index a length v array nezadávejte platný rozsah.index and length do not specify a valid range in array.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v array neimplementuje rozhraní IComparable.comparer is null, and one or more elements in array do not implement the IComparable interface.

Příklady

Následující příklad kódu ukazuje, jak seřadit hodnoty v Array pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrátí pořadí řazení.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Poznámky

Pokud je comparer null, každý prvek v zadaném rozsahu prvků v array musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným prvkem v array.If comparer is null, each element within the specified range of elements in array must implement the IComparable interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

.NET Framework obsahuje předdefinované implementace IComparer uvedené v následující tabulce.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementaceImplementation PopisDescription
System.Collections.CaseInsensitiveComparer Porovná všechny dva objekty, ale provede porovnání řetězců bez rozlišování velkých a malých písmen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porovná všechny dva objekty pomocí konvencí řazení aktuální jazykové verze.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porovná všechny dva objekty pomocí konvencí řazení invariantní jazykové verze.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porovná dva objekty typu T pomocí výchozího pořadí řazení typu.Compares two objects of type T by using the type's default sort order.

Můžete také podporovat vlastní porovnání poskytnutím instance vlastní implementace IComparer do parametru comparer.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Tento příklad provede definováním třídy ReverseComparer, která vrátí výchozí pořadí řazení pro instance typu a provede porovnání řetězců bez rozlišení velkých a malých písmen.The example does this by defining a ReverseComparer class that reverses the default sort order for instances of a type and performs case-insensitive string comparison.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Seřadí rozsah prvků ve dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

public:
 static void Sort(Array ^ keys, Array ^ items, int index, int length, System::Collections::IComparer ^ comparer);
public static void Sort (Array keys, Array items, int index, int length, System.Collections.IComparer comparer);
static member Sort : Array * Array * int * int * System.Collections.IComparer -> unit
Public Shared Sub Sort (keys As Array, items As Array, index As Integer, length As Integer, comparer As IComparer)

Parametry

keys
Array Array Array Array

Jednorozměrné Array obsahující klíče k seřazení.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednorozměrné Array obsahující položky, které odpovídají jednotlivým klíčům v keys @ no__t-2.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

-nebo--or- null pro řazení pouze keys @ no__t-2.null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Implementace IComparer, která se má použít při porovnávání prvků.The IComparer implementation to use when comparing elements.

-nebo--or- null pro použití implementace IComparable každého prvku.null to use the IComparable implementation of each element.

Výjimky

@No__t-0 @ no__t-1 je multidimenzionální.The keysArray is multidimensional.

-nebo--or- @No__t-0 @ no__t-1 je multidimenzionální.The itemsArray is multidimensional.

index je menší než dolní mez keys.index is less than the lower bound of keys.

-nebo--or- length je menší než nula.length is less than zero.

items není null a spodní mez keys se neshoduje s dolní mezíí items.items is not null, and the lower bound of keys does not match the lower bound of items.

-nebo--or- items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- index a length nespecifikujte platný rozsah v keys @ no__t-3.index and length do not specify a valid range in the keysArray.

-nebo--or- items není null a index a length nezadávejte platný rozsah items @ no__t-5.items is not null, and index and length do not specify a valid range in the itemsArray.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v keys @ no__t-3 neimplementuje rozhraní IComparable.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Příklady

Následující příklad kódu ukazuje, jak řadit dvě přidružená pole, kde první pole obsahuje klíče a druhé pole obsahuje hodnoty.The following code example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Řazení se provádí pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrací pořadí řazení.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

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

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew 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:" );

   // 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 );
}

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

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

*/

Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim 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)

   End Sub


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub

End Class


'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

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Pokud je comparer null, každý klíč v zadaném rozsahu prvků v keys @ no__t-3 musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným klíčem.If comparer is null, each key within the specified range of elements in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

.NET Framework obsahuje předdefinované implementace IComparer uvedené v následující tabulce.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementaceImplementation PopisDescription
System.Collections.CaseInsensitiveComparer Porovná všechny dva objekty, ale provede porovnání řetězců bez rozlišování velkých a malých písmen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porovná všechny dva objekty pomocí konvencí řazení aktuální jazykové verze.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porovná všechny dva objekty pomocí konvencí řazení invariantní jazykové verze.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porovná dva objekty typu T pomocí výchozího pořadí řazení typu.Compares two objects of type T by using the type's default sort order.

Můžete také podporovat vlastní porovnání poskytnutím instance vlastní implementace IComparer do parametru comparer.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Tento příklad provede definováním vlastní implementace IComparer, která vrátí výchozí pořadí řazení a provede porovnání řetězců bez rozlišení velkých a malých písmen.The example does this by defining a custom IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Seřadí prvky v rozsahu prvků v jednorozměrném Array pomocí IComparable implementace každého prvku Array.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

public:
 static void Sort(Array ^ array, int index, int length);
public static void Sort (Array array, int index, int length);
static member Sort : Array * int * int -> unit

Parametry

array
Array Array Array Array

Jednorozměrné Array pro řazení.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

Výjimky

array je multidimenzionální.array is multidimensional.

index je menší než dolní mez array.index is less than the lower bound of array.

-nebo--or- length je menší než nula.length is less than zero.

index a length v array nezadávejte platný rozsah.index and length do not specify a valid range in array.

Jeden nebo více prvků v array neimplementuje rozhraní IComparable.One or more elements in array do not implement the IComparable interface.

Příklady

Následující příklad kódu ukazuje, jak seřadit hodnoty v Array pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrátí pořadí řazení.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Poznámky

Každý prvek v zadaném rozsahu prvků v array musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným prvkem v array.Each element within the specified range of elements in array must implement the IComparable interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Viz také

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Seřadí rozsah prvků ve dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace každého klíče IComparable.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

public:
 static void Sort(Array ^ keys, Array ^ items, int index, int length);
public static void Sort (Array keys, Array items, int index, int length);
static member Sort : Array * Array * int * int -> unit
Public Shared Sub Sort (keys As Array, items As Array, index As Integer, length As Integer)

Parametry

keys
Array Array Array Array

Jednorozměrné Array obsahující klíče k seřazení.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednorozměrné Array obsahující položky, které odpovídají jednotlivým klíčům v keys @ no__t-2.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

-nebo--or- null pro řazení pouze keys @ no__t-2.null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

Výjimky

@No__t-0 @ no__t-1 je multidimenzionální.The keysArray is multidimensional.

-nebo--or- @No__t-0 @ no__t-1 je multidimenzionální.The itemsArray is multidimensional.

index je menší než dolní mez keys.index is less than the lower bound of keys.

-nebo--or- length je menší než nula.length is less than zero.

items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- index a length nespecifikujte platný rozsah v keys @ no__t-3.index and length do not specify a valid range in the keysArray.

-nebo--or- items není null a index a length nezadávejte platný rozsah items @ no__t-5.items is not null, and index and length do not specify a valid range in the itemsArray.

Jeden nebo více prvků v keys @ no__t-1 neimplementuje rozhraní IComparable.One or more elements in the keysArray do not implement the IComparable interface.

Příklady

Následující příklad kódu ukazuje, jak řadit dvě přidružená pole, kde první pole obsahuje klíče a druhé pole obsahuje hodnoty.The following code example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Řazení se provádí pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrací pořadí řazení.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

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

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew 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:" );

   // 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 );
}

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

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

*/

Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim 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)

   End Sub


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub

End Class


'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

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Každý klíč v zadaném rozsahu prvků keys @ no__t-1 musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným klíčem.Each key within the specified range of elements in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Viz také

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Seřadí prvky v jednorozměrném Array pomocí zadaného IComparer.Sorts the elements in a one-dimensional Array using the specified IComparer.

public:
 static void Sort(Array ^ array, System::Collections::IComparer ^ comparer);
public static void Sort (Array array, System.Collections.IComparer comparer);
static member Sort : Array * System.Collections.IComparer -> unit

Parametry

array
Array Array Array Array

Jednorozměrné pole, které se má seřaditThe one-dimensional array to sort.

comparer
IComparer IComparer IComparer IComparer

Implementace, která se má použít při porovnávání elementů.The implementation to use when comparing elements.

-nebo--or- null pro použití implementace IComparable každého prvku.null to use the IComparable implementation of each element.

Výjimky

array je multidimenzionální.array is multidimensional.

comparer je null a jeden nebo více prvků v array neimplementuje rozhraní IComparable.comparer is null, and one or more elements in array do not implement the IComparable interface.

Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

Příklady

Následující příklad seřadí hodnoty v poli řetězců pomocí výchozí porovnávací metody.The following example sorts the values in a string array by using the default comparer. Definuje také vlastní implementaci IComparer s názvem ReverseComparer, která při provádění porovnání řetězců bez rozlišování velkých a malých písmen vrátí výchozí pořadí řazení objektu.It also defines a custom IComparer implementation named ReverseComparer that reverses an object's default sort order while performing a case-insensitive string comparison. Všimněte si, že výstup se může lišit v závislosti na aktuální jazykové verzi.Note that the output might vary depending on the current culture.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Poznámky

Pokud je comparer null, každý prvek array musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným prvkem v array.If comparer is null, each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

.NET Framework obsahuje předdefinované implementace IComparer uvedené v následující tabulce.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementaceImplementation PopisDescription
System.Collections.CaseInsensitiveComparer Porovná všechny dva objekty, ale provede porovnání řetězců bez rozlišování velkých a malých písmen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porovná všechny dva objekty pomocí konvencí řazení aktuální jazykové verze.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porovná všechny dva objekty pomocí konvencí řazení invariantní jazykové verze.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porovná dva objekty typu T pomocí výchozího pořadí řazení typu.Compares two objects of type T by using the type's default sort order.

Můžete také podporovat vlastní porovnání poskytnutím instance vlastní implementace IComparer do parametru comparer.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Tento příklad provede definováním třídy ReverseComparer, která vrátí výchozí pořadí řazení pro instance typu a provede porovnání řetězců bez rozlišení velkých a malých písmen.The example does this by defining a ReverseComparer class that reverses the default sort order for instances of a type and performs case-insensitive string comparison.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Seřadí dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

public:
 static void Sort(Array ^ keys, Array ^ items, System::Collections::IComparer ^ comparer);
public static void Sort (Array keys, Array items, System.Collections.IComparer comparer);
static member Sort : Array * Array * System.Collections.IComparer -> unit
Public Shared Sub Sort (keys As Array, items As Array, comparer As IComparer)

Parametry

keys
Array Array Array Array

Jednorozměrné Array obsahující klíče k seřazení.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednorozměrné Array obsahující položky, které odpovídají jednotlivým klíčům v keys @ no__t-2.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

-nebo--or- null pro řazení pouze keys @ no__t-2.null to sort only the keysArray.

comparer
IComparer IComparer IComparer IComparer

Implementace IComparer, která se má použít při porovnávání prvků.The IComparer implementation to use when comparing elements.

-nebo--or- null pro použití implementace IComparable každého prvku.null to use the IComparable implementation of each element.

Výjimky

@No__t-0 @ no__t-1 je multidimenzionální.The keysArray is multidimensional.

-nebo--or- @No__t-0 @ no__t-1 je multidimenzionální.The itemsArray is multidimensional.

items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v keys @ no__t-3 neimplementuje rozhraní IComparable.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Příklady

Následující příklad ukazuje, jak řadit dvě přidružená pole, kde první pole obsahuje klíče a druhé pole obsahuje hodnoty.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Řazení se provádí pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrací pořadí řazení.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

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

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew 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:" );

   // 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 );
}

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

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

*/

Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim 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)

   End Sub


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub

End Class


'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

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Pokud je comparer null, každý klíč v keys @ no__t-3 musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným klíčem.If comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

.NET Framework obsahuje předdefinované implementace IComparer uvedené v následující tabulce.The .NET Framework includes predefined IComparer implementations listed in the following table.

ImplementaceImplementation PopisDescription
System.Collections.CaseInsensitiveComparer Porovná všechny dva objekty, ale provede porovnání řetězců bez rozlišování velkých a malých písmen.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Porovná všechny dva objekty pomocí konvencí řazení aktuální jazykové verze.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Porovná všechny dva objekty pomocí konvencí řazení invariantní jazykové verze.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Porovná dva objekty typu T pomocí výchozího pořadí řazení typu.Compares two objects of type T by using the type's default sort order.

Můžete také podporovat vlastní porovnání poskytnutím instance vlastní implementace IComparer do parametru comparer.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Tento příklad provede definováním implementace IComparer, která vrátí výchozí pořadí řazení a provede porovnávání řetězců bez rozlišení velkých a malých písmen.The example does this by defining an IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length keys.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of keys.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Seřadí dvojici jednorozměrného objektu @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace každého klíče IComparable.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

public:
 static void Sort(Array ^ keys, Array ^ items);
public static void Sort (Array keys, Array items);
static member Sort : Array * Array -> unit
Public Shared Sub Sort (keys As Array, items As Array)

Parametry

keys
Array Array Array Array

Jednorozměrné Array obsahující klíče k seřazení.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Jednorozměrné Array obsahující položky, které odpovídají jednotlivým klíčům v keys @ no__t-2.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

-nebo--or- null pro řazení pouze keys @ no__t-2.null to sort only the keysArray.

Výjimky

@No__t-0 @ no__t-1 je multidimenzionální.The keysArray is multidimensional.

-nebo--or- @No__t-0 @ no__t-1 je multidimenzionální.The itemsArray is multidimensional.

items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

Jeden nebo více prvků v keys @ no__t-1 neimplementuje rozhraní IComparable.One or more elements in the keysArray do not implement the IComparable interface.

Příklady

Následující příklad ukazuje, jak řadit dvě přidružená pole, kde první pole obsahuje klíče a druhé pole obsahuje hodnoty.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Řazení se provádí pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrací pořadí řazení.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class myReverserClass: public IComparer
{
private:

   // Calls CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
   }
};

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

int main()
{
   // Creates and initializes a new Array and a new custom comparer.
   array<String^>^myKeys = {"red","GREEN","YELLOW","BLUE","purple","black","orange"};
   array<String^>^myValues = {"strawberries","PEARS","LIMES","BERRIES","grapes","olives","cantaloupe"};
   IComparer^ myComparer = gcnew 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:" );

   // 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 );
}

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

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

*/

Imports System.Collections

Public Class SamplesArray

   Public Class myReverserClass
      Implements IComparer

      ' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      Function Compare(x As [Object], y As [Object]) As Integer _
         Implements IComparer.Compare
         Return New CaseInsensitiveComparer().Compare(y, x)
      End Function 'IComparer.Compare

   End Class


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim 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)

   End Sub


   Public Shared Sub PrintKeysAndValues(myKeys() As [String], myValues() As [String])

      Dim i As Integer
      For i = 0 To myKeys.Length - 1
         Console.WriteLine("   {0,-10}: {1}", myKeys(i), myValues(i))
      Next i
      Console.WriteLine()

   End Sub

End Class


'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

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Každý klíč v keys @ no__t-1 musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným klíčem.Each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length keys.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of keys.

Viz také

Sort(Array) Sort(Array) Sort(Array)

Seřadí prvky v celém jednorozměrném Array pomocí implementace IComparable každého prvku Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

public:
 static void Sort(Array ^ array);
public static void Sort (Array array);
static member Sort : Array -> unit

Parametry

array
Array Array Array Array

Jednorozměrné Array pro řazení.The one-dimensional Array to sort.

Výjimky

array je multidimenzionální.array is multidimensional.

Jeden nebo více prvků v array neimplementuje rozhraní IComparable.One or more elements in array do not implement the IComparable interface.

Příklady

Následující příklad kódu ukazuje, jak seřadit hodnoty v Array pomocí výchozí porovnávací metody a vlastní porovnávací metody, která obrátí pořadí řazení.The following code example shows how to sort the values in an Array using the default comparer and a custom comparer that reverses the sort order. Všimněte si, že výsledek se může lišit v závislosti na aktuálním CultureInfo.Note that the result might vary depending on the current CultureInfo.

using namespace System;
using namespace System::Collections;

public ref class ReverseComparer : IComparer
{
public:
   // Call CaseInsensitiveComparer::Compare with the parameters reversed.
   virtual int Compare(Object^ x, Object^ y) = IComparer::Compare
   {
      return ((gcnew CaseInsensitiveComparer)->Compare(y, x));
   }
};

void DisplayValues(array<String^>^ arr)
{
   for (int i = arr->GetLowerBound(0); i <= arr->GetUpperBound(0); i++)
      Console::WriteLine( "   [{0}] : {1}", i, arr[ i ] );

   Console::WriteLine();
}

int main()
{
   // Create and initialize a new array. and a new custom comparer.
   array<String^>^ words = { "The","QUICK","BROWN","FOX","jumps",
                             "over","the","lazy","dog" };
   // Instantiate the reverse comparer.
   IComparer^ revComparer = gcnew 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);
}

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

*/
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    
Imports System.Collections

Public Class ReverseComparer : Implements IComparer
   ' Call CaseInsensitiveComparer.Compare with the parameters reversed.
   Function Compare(x As Object, y As Object) As Integer _
            Implements IComparer.Compare
      Return New CaseInsensitiveComparer().Compare(y, x)
   End Function 
End Class

Public Module Example
   Public Sub Main()
      ' Create and initialize a new array.
      Dim words() As String =  { "The", "QUICK", "BROWN", "FOX", "jumps", 
                                 "over", "the", "lazy", "dog" }
      ' Instantiate a new custom comparer.
      Dim revComparer As 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)
   End Sub 

   Public Sub DisplayValues(arr() As String)
      For i As Integer = arr.GetLowerBound(0) To arr.GetUpperBound(0)
         Console.WriteLine("   [{0}] : {1}", i, arr(i))
      Next 
      Console.WriteLine()
   End Sub 
End Module 
' 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

Poznámky

Každý prvek array musí implementovat rozhraní IComparable, aby bylo možné porovnat s každým jiným prvkem v array.Each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Viz také

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Seřadí prvky v celé Array pomocí implementace obecného rozhraní IComparable<T> každého prvku Array.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array);
public static void Sort<T> (T[] array);
static member Sort : 'T[] -> unit
Public Shared Sub Sort(Of T) (array As T())

Parametry typu

T

Typ prvků pole.The type of the elements of the array.

Parametry

array
T[]

Jednorozměrného Array založeného na nule pro řazení.The one-dimensional, zero-based Array to sort.

Výjimky

Jeden nebo více prvků v array neimplementuje obecné rozhraní IComparable<T>.One or more elements in array do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje přetížení obecné metody Sort<T>(T[]) a přetížení obecné metody BinarySearch<T>(T[], T).The following code example demonstrates the Sort<T>(T[]) generic method overload and the BinarySearch<T>(T[], T) generic method overload. Je vytvořeno pole řetězců, a to bez konkrétního pořadí.An array of strings is created, in no particular order.

Pole je zobrazeno, seřazeno a znovu zobrazeno.The array is displayed, sorted, and displayed again.

Poznámka

Volání obecných metod Sort a BinarySearch nevypadají žádné jiné než volání jejich neobecných protějšků, protože Visual Basic, C#a C++ odvozují typ parametru obecného typu z typu prvního argumentu.The calls to the Sort and BinarySearch generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

Metoda přetížení obecné metody BinarySearch<T>(T[], T) se pak používá pro hledání dvou řetězců, z nichž jeden není v poli a v jednom z nich.The BinarySearch<T>(T[], T) generic method overload is then used to search for two strings, one that is not in the array and one that is. Pole a návratová hodnota metody BinarySearch jsou předány do obecné metody ShowWhere, která zobrazí hodnotu indexu, pokud se řetězec najde, a jinak prvky, které by hledaný řetězec znamenal mezi, pokud byl v poli.The array and the return value of the BinarySearch method are passed to the ShowWhere generic method, which displays the index value if the string is found, and otherwise the elements the search string would fall between if it were in the array. Index je záporný, pokud řetězec není n polem, takže metoda ShowWhere přebírá logický doplněk (~ operátor in C# a vizuál C++Xor -1 v Visual Basic) k získání indexu prvního prvku v seznamu, který je větší než vyhledávací str. Ing.The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

using namespace System;
using namespace System::Collections::Generic;

generic<typename T> void ShowWhere(array<T>^ arr, int index)
{
    if (index<0)
    {
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        //
        index = ~index;

        Console::Write("Not found. Sorts between: ");

        if (index == 0)
            Console::Write("beginning of array and ");
        else
            Console::Write("{0} and ", arr[index-1]);

        if (index == arr->Length)
            Console::WriteLine("end of array.");
        else
            Console::WriteLine("{0}.", arr[index]);
    }
    else
    {
        Console::WriteLine("Found at index {0}.", index);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nSort");
    Array::Sort(dinosaurs);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch for 'Coelophysis':");
    int index = Array::BinarySearch(dinosaurs, "Coelophysis");
    ShowWhere(dinosaurs, index);

    Console::WriteLine("\nBinarySearch for 'Tyrannosaurus':");
    index = Array::BinarySearch(dinosaurs, "Tyrannosaurus");
    ShowWhere(dinosaurs, index);
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Amargasaurus and Deinonychus.

BinarySearch for 'Tyrannosaurus':
Found at index 5.
 */
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis");
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus");
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Amargasaurus and Deinonychus.

BinarySearch for 'Tyrannosaurus':
Found at index 5.
 */
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis")
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus")
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Edmontosaurus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Amargasaurus and Deinonychus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 5.

Poznámky

Každý prvek array musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným prvkem v array.Each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Viz také

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Seřadí prvky v Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts the elements in an Array using the specified IComparer<T> generic interface.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, System::Collections::Generic::IComparer<T> ^ comparer);
public static void Sort<T> (T[] array, System.Collections.Generic.IComparer<T> comparer);
static member Sort : 'T[] * System.Collections.Generic.IComparer<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), comparer As IComparer(Of T))

Parametry typu

T

Typ prvků pole.The type of the elements of the array.

Parametry

array
T[]

Jednorozměrné, nulové základní Array pro řazeníThe one-dimensional, zero-base Array to sort

comparer
IComparer<T> IComparer<T> IComparer<T> IComparer<T>

Implementace obecného rozhraní IComparer<T>, která se má použít při porovnávání prvků, nebo null pro použití implementace obecného rozhraní IComparable<T> pro každý prvek.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Výjimky

comparer je null a jeden nebo více prvků v array neimplementuje obecné rozhraní IComparable<T>.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

Příklady

Následující příklad kódu ukazuje přetížení obecné metody Sort<T>(T[], IComparer<T>) a přetížení obecné metody BinarySearch<T>(T[], T, IComparer<T>).The following code example demonstrates the Sort<T>(T[], IComparer<T>) generic method overload and the BinarySearch<T>(T[], T, IComparer<T>) generic method overload.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Pole je zobrazeno, seřazeno a znovu zobrazeno.The array is displayed, sorted, and displayed again. Pole musí být seřazena, aby bylo možné použít metodu BinarySearch.Arrays must be sorted in order to use the BinarySearch method.

Poznámka

Volání obecných metod Sort<T>(T[], IComparer<T>) a BinarySearch<T>(T[], T, IComparer<T>) nevypadají žádné jiné než volání jejich neobecných protějšků, protože Visual Basic, C#a C++ odvozují typ parametru obecného typu z typu prvního argumentu.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

Metoda přetížení obecné metody BinarySearch<T>(T[], T, IComparer<T>) se pak používá pro hledání dvou řetězců, z nichž jeden není v poli a v jednom z nich.The BinarySearch<T>(T[], T, IComparer<T>) generic method overload is then used to search for two strings, one that is not in the array and one that is. Pole a návratová hodnota metody BinarySearch<T>(T[], T, IComparer<T>) jsou předány do obecné metody ShowWhere, která zobrazí hodnotu indexu, pokud se řetězec najde, a jinak prvky, které by hledaný řetězec znamenal mezi, pokud byl v poli.The array and the return value of the BinarySearch<T>(T[], T, IComparer<T>) method are passed to the ShowWhere generic method, which displays the index value if the string is found, and otherwise the elements the search string would fall between if it were in the array. Index je záporný, pokud řetězec není n polem, takže metoda ShowWhere přebírá logický doplněk (~ operátor in C# a vizuál C++Xor -1 v Visual Basic) k získání indexu prvního prvku v seznamu, který je větší než vyhledávací str. Ing.The index is negative if the string is not n the array, so the ShowWhere method takes the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) to obtain the index of the first element in the list that is larger than the search string.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

generic<typename T> void ShowWhere(array<T>^ arr, int index)
{
    if (index<0)
    {
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        //
        index = ~index;

        Console::Write("Not found. Sorts between: ");

        if (index == 0)
            Console::Write("beginning of array and ");
        else
            Console::Write("{0} and ", arr[index-1]);

        if (index == arr->Length)
            Console::WriteLine("end of array.");
        else
            Console::WriteLine("{0}.", arr[index]);
    }
    else
    {
        Console::WriteLine("Found at index {0}.", index);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort");
    Array::Sort(dinosaurs, rc);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch for 'Coelophysis':");
    int index = Array::BinarySearch(dinosaurs, "Coelophysis", rc);
    ShowWhere(dinosaurs, index);

    Console::WriteLine("\nBinarySearch for 'Tyrannosaurus':");
    index = Array::BinarySearch(dinosaurs, "Tyrannosaurus", rc);
    ShowWhere(dinosaurs, index);
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis", rc)
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Tyrannosaurus
'Pachycephalosaurus
'Mamenchisaurus
'Edmontosaurus
'Deinonychus
'Amargasaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Deinonychus and Amargasaurus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 0.

Poznámky

Pokud je comparer null, každý prvek array musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným prvkem v array.If comparer is null, each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Seřadí prvky v Array pomocí zadaného Comparison<T>.Sorts the elements in an Array using the specified Comparison<T>.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, Comparison<T> ^ comparison);
public static void Sort<T> (T[] array, Comparison<T> comparison);
static member Sort : 'T[] * Comparison<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), comparison As Comparison(Of T))

Parametry typu

T

Typ prvků pole.The type of the elements of the array.

Parametry

array
T[]

Jednorozměrného Array založeného na nule pro řazeníThe one-dimensional, zero-based Array to sort

comparison
Comparison<T> Comparison<T> Comparison<T> Comparison<T>

@No__t-0, který se má použít při porovnávání elementů.The Comparison<T> to use when comparing elements.

Výjimky

array je null.array is null.

-nebo--or- comparison je null.comparison is null.

Implementace comparison způsobila při řazení chybu.The implementation of comparison caused an error during the sort. Například comparison nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparison might not return 0 when comparing an item with itself.

Příklady

Následující příklad kódu ukazuje přetížení metody Sort(Comparison<T>).The following code example demonstrates the Sort(Comparison<T>) method overload.

Příklad kódu definuje alternativní metodu porovnání pro řetězce s názvem CompareDinosByLength.The code example defines an alternative comparison method for strings, named CompareDinosByLength. Tato metoda funguje takto: Nejprve jsou komparand testovány pro @ no__t-0 a odkaz s hodnotou null je považován za menší než null.This method works as follows: First, the comparands are tested fornull, and a null reference is treated as less than a non-null. Za druhé se délky řetězců rovnají a delší řetězec se považuje za větší.Second, the string lengths are compared, and the longer string is deemed to be greater. Třetí, pokud jsou délky stejné, použije se běžné porovnání řetězců.Third, if the lengths are equal, ordinary string comparison is used.

Pole řetězců se vytvoří a naplní se čtyřmi řetězci, a to bez konkrétního pořadí.A array of strings is created and populated with four strings, in no particular order. Seznam obsahuje také prázdný řetězec a odkaz s hodnotou null.The list also includes an empty string and a null reference. Zobrazí se seznam seřazený pomocí obecného delegáta Comparison<T> reprezentujícího metodu CompareDinosByLength a znovu se zobrazí.The list is displayed, sorted using a Comparison<T> generic delegate representing the CompareDinosByLength method, and displayed again.

using namespace System;
using namespace System::Collections::Generic;

int CompareDinosByLength(String^ x, String^ y)
{
    if (x == nullptr)
    {
        if (y == nullptr)
        {
            // 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 == nullptr)
            // ...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);
            }
        }
    }
};

void Display(array<String^>^ arr)
{
    Console::WriteLine();
    for each(String^ s in arr)
    {
        if (s == nullptr)
            Console::WriteLine("(null)");
        else
            Console::WriteLine("\"{0}\"", s);
    }
};

void main()
{
    array<String^>^ dinosaurs = { 
        "Pachycephalosaurus",
        "Amargasaurus",
        "",
        nullptr,
        "Mamenchisaurus",
        "Deinonychus" };
    Display(dinosaurs);

    Console::WriteLine("\nSort with generic Comparison<String^> delegate:");
    Array::Sort(dinosaurs,
        gcnew Comparison<String^>(CompareDinosByLength));
    Display(dinosaurs);

}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<String^> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */
using System;
using System.Collections.Generic;

public class Example
{
    private static int CompareDinosByLength(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 static void Main()
    {
        string[] dinosaurs = {
            "Pachycephalosaurus",
            "Amargasaurus",
            "",
            null,
            "Mamenchisaurus",
            "Deinonychus" };
        Display(dinosaurs);

        Console.WriteLine("\nSort with generic Comparison<string> delegate:");
        Array.Sort(dinosaurs, CompareDinosByLength);
        Display(dinosaurs);

    }

    private static void Display(string[] arr)
    {
        Console.WriteLine();
        foreach( string s in arr )
        {
            if (s == null)
                Console.WriteLine("(null)");
            else
                Console.WriteLine("\"{0}\"", s);
        }
    }
}

/* This code example produces the following output:

"Pachycephalosaurus"
"Amargasaurus"
""
(null)
"Mamenchisaurus"
"Deinonychus"

Sort with generic Comparison<string> delegate:

(null)
""
"Deinonychus"
"Amargasaurus"
"Mamenchisaurus"
"Pachycephalosaurus"
 */
Imports System.Collections.Generic

Public Class Example

    Private Shared Function CompareDinosByLength( _
        ByVal x As String, ByVal y As String) As Integer

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' 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)
                End If
            End If
        End If

    End Function

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "", _
            Nothing, _
            "Mamenchisaurus", _
            "Deinonychus" }
        Display(dinosaurs)

        Console.WriteLine(vbLf & "Sort with generic Comparison(Of String) delegate:")
        Array.Sort(dinosaurs, AddressOf CompareDinosByLength)
        Display(dinosaurs)

    End Sub

    Private Shared Sub Display(ByVal arr() As String)
        Console.WriteLine()
        For Each s As String In arr
            If s Is Nothing Then
                Console.WriteLine("(Nothing)")
            Else
                Console.WriteLine("""{0}""", s)
            End If
        Next
    End Sub
End Class

' This code example produces the following output:
'
'"Pachycephalosaurus"
'"Amargasaurus"
'""
'(Nothing)
'"Mamenchisaurus"
'"Deinonychus"
'
'Sort with generic Comparison(Of String) delegate:
'
'(Nothing)
'""
'"Deinonychus"
'"Amargasaurus"
'"Mamenchisaurus"
'"Pachycephalosaurus"

Poznámky

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá algoritmus introspective Sort (introsort) následujícím způsobem:This method uses introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32)

Seřadí prvky v rozsahu prvků Array pomocí implementace obecného rozhraní IComparable<T> pro každý prvek Array.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, int index, int length);
public static void Sort<T> (T[] array, int index, int length);
static member Sort : 'T[] * int * int -> unit
Public Shared Sub Sort(Of T) (array As T(), index As Integer, length As Integer)

Parametry typu

T

Typ prvků pole.The type of the elements of the array.

Parametry

array
T[]

Jednorozměrného Array založeného na nule pro řazeníThe one-dimensional, zero-based Array to sort

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

Výjimky

index je menší než dolní mez array.index is less than the lower bound of array.

-nebo--or- length je menší než nula.length is less than zero.

index a length v array nezadávejte platný rozsah.index and length do not specify a valid range in array.

Jeden nebo více prvků v array neimplementuje obecné rozhraní IComparable<T>.One or more elements in array do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje přetížení obecné metody Sort<T>(T[], Int32, Int32) a přetížení obecné metody Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) pro řazení rozsahu v poli.The following code example demonstrates the Sort<T>(T[], Int32, Int32) generic method overload and the Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload for sorting a range in an array.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Příklad kódu vytvoří a zobrazí pole dinosaurů názvů, které se skládá ze tří herbivores následovaných třemi přími zvířaty (tyrannosaurids, aby byly přesné).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Přetížení obecné metody Sort<T>(T[], Int32, Int32) slouží k seřazení posledních tří prvků pole, které je pak zobrazeno.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Přetížení obecné metody Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) se používá s ReverseCompare k řazení posledních tří prvků v opačném pořadí.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload is used with ReverseCompare to sort the last three elements in reverse order. Znovu se zobrazí dinosaursně zaměnitelné.The thoroughly confused dinosaurs are displayed again.

Poznámka

Volání obecných metod Sort<T>(T[], IComparer<T>) a BinarySearch<T>(T[], T, IComparer<T>) nevypadají žádné jiné než volání jejich neobecných protějšků, protože Visual Basic, C#a C++ odvozují typ parametru obecného typu z typu prvního argumentu.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Mamenchisaurus",
                                 "Tarbosaurus",
                                 "Tyrannosaurus", 
                                 "Albertasaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nSort(dinosaurs, 3, 3)");
    Array::Sort(dinosaurs, 3, 3);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, 3, 3, rc)");
    Array::Sort(dinosaurs, 3, 3, rc);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Mamenchisaurus", 
                              "Tarbosaurus",
                              "Tyrannosaurus", 
                              "Albertasaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nSort(dinosaurs, 3, 3)");
        Array.Sort(dinosaurs, 3, 3);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, 3, 3, rc)");
        Array.Sort(dinosaurs, 3, 3, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Tarbosaurus", _
            "Tyrannosaurus", _
            "Albertasaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3)")
        Array.Sort(dinosaurs, 3, 3)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3, rc)")
        Array.Sort(dinosaurs, 3, 3, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tarbosaurus
'Tyrannosaurus
'Albertasaurus
'
'Sort(dinosaurs, 3, 3)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Albertasaurus
'Tarbosaurus
'Tyrannosaurus
'
'Sort(dinosaurs, 3, 3, rc)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tyrannosaurus
'Tarbosaurus
'Albertasaurus

Poznámky

Každý prvek v zadaném rozsahu prvků v array musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným prvkem v array.Each element within the specified range of elements in array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Viz také

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Seřadí prvky v rozsahu prvků Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

public:
generic <typename T>
 static void Sort(cli::array <T> ^ array, int index, int length, System::Collections::Generic::IComparer<T> ^ comparer);
public static void Sort<T> (T[] array, int index, int length, System.Collections.Generic.IComparer<T> comparer);
static member Sort : 'T[] * int * int * System.Collections.Generic.IComparer<'T> -> unit
Public Shared Sub Sort(Of T) (array As T(), index As Integer, length As Integer, comparer As IComparer(Of T))

Parametry typu

T

Typ prvků pole.The type of the elements of the array.

Parametry

array
T[]

Jednorozměrného Array založeného na nule pro řazení.The one-dimensional, zero-based Array to sort.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

comparer
IComparer<T> IComparer<T> IComparer<T> IComparer<T>

Implementace obecného rozhraní IComparer<T>, která se má použít při porovnávání prvků, nebo null pro použití implementace obecného rozhraní IComparable<T> pro každý prvek.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Výjimky

index je menší než dolní mez array.index is less than the lower bound of array.

-nebo--or- length je menší než nula.length is less than zero.

index a length v array nezadávejte platný rozsah.index and length do not specify a valid range in array.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v array neimplementuje obecné rozhraní IComparable<T>.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje přetížení obecné metody Sort<T>(T[], Int32, Int32) a přetížení obecné metody Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) pro řazení rozsahu v poli.The following code example demonstrates the Sort<T>(T[], Int32, Int32) generic method overload and the Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload for sorting a range in an array.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Příklad kódu vytvoří a zobrazí pole dinosaurů názvů, které se skládá ze tří herbivores následovaných třemi přími zvířaty (tyrannosaurids, aby byly přesné).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Přetížení obecné metody Sort<T>(T[], Int32, Int32) slouží k seřazení posledních tří prvků pole, které je pak zobrazeno.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Přetížení obecné metody Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) se používá s ReverseCompare k řazení posledních tří prvků v opačném pořadí.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overload is used with ReverseCompare to sort the last three elements in reverse order. Znovu se zobrazí dinosaursně zaměnitelné.The thoroughly confused dinosaurs are displayed again.

Poznámka

Volání obecných metod Sort<T>(T[], IComparer<T>) a BinarySearch<T>(T[], T, IComparer<T>) nevypadají žádné jiné než volání jejich neobecných protějšků, protože Visual Basic, C#a C++ odvozují typ parametru obecného typu z typu prvního argumentu.The calls to the Sort<T>(T[], IComparer<T>) and BinarySearch<T>(T[], T, IComparer<T>) generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first argument. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Mamenchisaurus",
                                 "Tarbosaurus",
                                 "Tyrannosaurus", 
                                 "Albertasaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nSort(dinosaurs, 3, 3)");
    Array::Sort(dinosaurs, 3, 3);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, 3, 3, rc)");
    Array::Sort(dinosaurs, 3, 3, rc);

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Mamenchisaurus", 
                              "Tarbosaurus",
                              "Tyrannosaurus", 
                              "Albertasaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nSort(dinosaurs, 3, 3)");
        Array.Sort(dinosaurs, 3, 3);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, 3, 3, rc)");
        Array.Sort(dinosaurs, 3, 3, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Tarbosaurus", _
            "Tyrannosaurus", _
            "Albertasaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3)")
        Array.Sort(dinosaurs, 3, 3)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort(dinosaurs, 3, 3, rc)")
        Array.Sort(dinosaurs, 3, 3, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tarbosaurus
'Tyrannosaurus
'Albertasaurus
'
'Sort(dinosaurs, 3, 3)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Albertasaurus
'Tarbosaurus
'Tyrannosaurus
'
'Sort(dinosaurs, 3, 3, rc)
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Tyrannosaurus
'Tarbosaurus
'Albertasaurus

Poznámky

Pokud je comparer null, každý prvek v zadaném rozsahu prvků v array musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným prvkem v array.If comparer is null, each element within the specified range of elements in array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Seřadí pár objektů Array (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace obecného rozhraní IComparable<T> pro každý klíč.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items);
static member Sort : 'Key[] * 'Value[] -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue())

Parametry typu

TKey

Typ prvků pole klíčů.The type of the elements of the key array.

TValue

Typ prvků pole položek.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednorozměrného, nulového Array, který obsahuje klíče k seřazení.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Jednorozměrného, nulového Array, který obsahuje položky, které odpovídají klíčům v keys nebo null pro řazení pouze keys.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

Výjimky

items není null a spodní mez keys se neshoduje s dolní mezíí items.items is not null, and the lower bound of keys does not match the lower bound of items.

-nebo--or- items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

Jeden nebo více prvků v keys @ no__t-1 neimplementuje obecné rozhraní IComparable<T>.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje přetížení obecné metody Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) a Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>), pro řazení párů polí reprezentujících klíče a hodnoty.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Ukázkový kód vytvoří a zobrazí pole názvů dinosaurů (klíče) a pole celých čísel reprezentujících maximální délku každého dinosaura v metrech (hodnoty).The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Pole jsou poté několikrát seřazena a zobrazena:The arrays are then sorted and displayed several times:

Poznámka

Volání obecných metod vyhledávání se na pohled nijak neliší od volání jejich protějšků, které obecné nejsou, protože jazyky Visual Basic, C# a C++ odvozují parametry obecného typu z typu prvních dvou argumentů.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes)");
    Array::Sort(dinosaurs, dinosaurSizes);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Každý klíč v keys @ no__t-1 musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným klíčem.Each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Viz také

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Seřadí pár objektů Array (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, System::Collections::Generic::IComparer<TKey> ^ comparer);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, System.Collections.Generic.IComparer<TKey> comparer);
static member Sort : 'Key[] * 'Value[] * System.Collections.Generic.IComparer<'Key> -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), comparer As IComparer(Of TKey))

Parametry typu

TKey

Typ prvků pole klíčů.The type of the elements of the key array.

TValue

Typ prvků pole položek.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednorozměrného, nulového Array, který obsahuje klíče k seřazení.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Jednorozměrného, nulového Array, který obsahuje položky, které odpovídají klíčům v keys nebo null pro řazení pouze keys.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

comparer
IComparer<TKey>

Implementace obecného rozhraní IComparer<T>, která se má použít při porovnávání prvků, nebo null pro použití implementace obecného rozhraní IComparable<T> pro každý prvek.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Výjimky

items není null a spodní mez keys se neshoduje s dolní mezíí items.items is not null, and the lower bound of keys does not match the lower bound of items.

-nebo--or- items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v keys @ no__t-3 neimplementuje obecné rozhraní IComparable<T>.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje Sort<TKey,TValue>(TKey[], TValue[]), [], TValue @ no__t-2xref: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 60% 601% 5B% 5D% 2CSystem. Collections. Generic. IComparer% 7B% 60% 600% 7D% 29 >, Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) a obecná metoda Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) přetížení pro řazení párů polí reprezentujících klíče a hodnoty.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29>,Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Ukázkový kód vytvoří a zobrazí pole názvů dinosaurů (klíče) a pole celých čísel reprezentujících maximální délku každého dinosaura v metrech (hodnoty).The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Pole jsou poté několikrát seřazena a zobrazena:The arrays are then sorted and displayed several times:

Poznámka

Volání obecných metod vyhledávání se na pohled nijak neliší od volání jejich protějšků, které obecné nejsou, protože jazyky Visual Basic, C# a C++ odvozují parametry obecného typu z typu prvních dvou argumentů.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes)");
    Array::Sort(dinosaurs, dinosaurSizes);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Pokud je comparer null, každý klíč v keys @ no__t-3 musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným klíčem.If comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazena pomocí algoritmu algoritmů heapsort a quicksort v nejhorším případě je tato metoda operací O (n log n), kde n je Length array.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is the Length of array.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Seřadí rozsah prvků ve dvojici objektů @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí implementace obecného rozhraní IComparable<T> s každým klíčem.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, int index, int length);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, int index, int length);
static member Sort : 'Key[] * 'Value[] * int * int -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), index As Integer, length As Integer)

Parametry typu

TKey

Typ prvků pole klíčů.The type of the elements of the key array.

TValue

Typ prvků pole položek.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednorozměrného, nulového Array, který obsahuje klíče k seřazení.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Jednorozměrného, nulového Array, který obsahuje položky, které odpovídají klíčům v keys nebo null pro řazení pouze keys.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

Výjimky

index je menší než dolní mez keys.index is less than the lower bound of keys.

-nebo--or- length je menší než nula.length is less than zero.

items není null a spodní mez keys se neshoduje s dolní mezíí items.items is not null, and the lower bound of keys does not match the lower bound of items.

-nebo--or- items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- index a length nespecifikujte platný rozsah v keys @ no__t-3.index and length do not specify a valid range in the keysArray.

-nebo--or- items není null a index a length nezadávejte platný rozsah items @ no__t-5.items is not null, and index and length do not specify a valid range in the itemsArray.

Jeden nebo více prvků v keys @ no__t-1 neimplementuje obecné rozhraní IComparable<T>.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue @ no__t-3xref: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 60% 601% 5B% 5D% 2CSystem. Int32% 2CSystem. Int32% 29 > a Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) přetížení obecných metod pro řazení páry polí reprezentujících klíče a hodnoty.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%29>, and Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) generic method overloads, for sorting pairs of arrays that represent keys and values.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Ukázkový kód vytvoří a zobrazí pole názvů dinosaurů (klíče) a pole celých čísel reprezentujících maximální délku každého dinosaura v metrech (hodnoty).The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Pole jsou poté několikrát seřazena a zobrazena:The arrays are then sorted and displayed several times:

Poznámka

Volání obecných metod vyhledávání se na pohled nijak neliší od volání jejich protějšků, které obecné nejsou, protože jazyky Visual Basic, C# a C++ odvozují parametry obecného typu z typu prvních dvou argumentů.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes)");
    Array::Sort(dinosaurs, dinosaurSizes);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Každý klíč v zadaném rozsahu prvků keys @ no__t-1 musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným klíčem.Each key within the specified range of elements in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Viz také

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Seřadí rozsah prvků ve dvojici objektů @no__t 0 (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného obecného rozhraní IComparer<T>.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

public:
generic <typename TKey, typename TValue>
 static void Sort(cli::array <TKey> ^ keys, cli::array <TValue> ^ items, int index, int length, System::Collections::Generic::IComparer<TKey> ^ comparer);
public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer<TKey> comparer);
static member Sort : 'Key[] * 'Value[] * int * int * System.Collections.Generic.IComparer<'Key> -> unit
Public Shared Sub Sort(Of TKey, TValue) (keys As TKey(), items As TValue(), index As Integer, length As Integer, comparer As IComparer(Of TKey))

Parametry typu

TKey

Typ prvků pole klíčů.The type of the elements of the key array.

TValue

Typ prvků pole položek.The type of the elements of the items array.

Parametry

keys
TKey[]

Jednorozměrného, nulového Array, který obsahuje klíče k seřazení.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Jednorozměrného, nulového Array, který obsahuje položky, které odpovídají klíčům v keys nebo null pro řazení pouze keys.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

index
Int32 Int32 Int32 Int32

Počáteční index úseku, který má být seřazen.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Počet prvků v řazeném úseku.The number of elements in the range to sort.

comparer
IComparer<TKey>

Implementace obecného rozhraní IComparer<T>, která se má použít při porovnávání prvků, nebo null pro použití implementace obecného rozhraní IComparable<T> pro každý prvek.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Výjimky

index je menší než dolní mez keys.index is less than the lower bound of keys.

-nebo--or- length je menší než nula.length is less than zero.

items není null a spodní mez keys se neshoduje s dolní mezíí items.items is not null, and the lower bound of keys does not match the lower bound of items.

-nebo--or- items není null a délka keys je větší než délka items.items is not null, and the length of keys is greater than the length of items.

-nebo--or- index a length nespecifikujte platný rozsah v keys @ no__t-3.index and length do not specify a valid range in the keysArray.

-nebo--or- items není null a index a length nezadávejte platný rozsah items @ no__t-5.items is not null, and index and length do not specify a valid range in the itemsArray.

-nebo--or- Implementace comparer způsobila při řazení chybu.The implementation of comparer caused an error during the sort. Například comparer nemusí vracet hodnotu 0 při porovnávání položky se sebou samým.For example, comparer might not return 0 when comparing an item with itself.

comparer je null a jeden nebo více prvků v keys @ no__t-3 neimplementuje obecné rozhraní IComparable<T>.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Příklady

Následující příklad kódu ukazuje Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) a [], TValue @ no__t-4xref: System. Array. Sort% 60% 602% 28% 60% 600% 5B% 5D% 2C% 60% 601% 5B% 5D% 2CSystem. Int32% 2CSystem. Int32% 2CSystem. Collections. Generic. IComparer% 7B % 60% 600% 7D% 29 > přetížení obecné metody pro řazení párů polí reprezentujících klíče a hodnoty.The following code example demonstrates the Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32), and [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%2CSystem.Collections.Generic.IComparer%7B%60%600%7D%29> generic method overloads, for sorting pairs of arrays that represent keys and values.

Příklad kódu definuje alternativní porovnávací metodu pro řetězce s názvem ReverseCompare, která implementuje obecné rozhraní IComparer<string> (IComparer(Of String) v Visual Basic, IComparer<String^> v C++jazyce Visual).The code example defines an alternative comparer for strings, named ReverseCompare, which implements the IComparer<string>(IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. Porovnávací metoda volá metodu CompareTo(String), přičemž přesměruje pořadí komparand tak, aby řetězce byly řazeny na maximum a nikoli jako nízké až vysoké.The comparer calls the CompareTo(String) method, reversing the order of the comparands so that the strings sort high-to-low instead of low-to-high.

Ukázkový kód vytvoří a zobrazí pole názvů dinosaurů (klíče) a pole celých čísel reprezentujících maximální délku každého dinosaura v metrech (hodnoty).The code example creates and displays an array of dinosaur names (the keys) and an array of integers representing the maximum length of each dinosaur in meters (the values). Pole jsou poté několikrát seřazena a zobrazena:The arrays are then sorted and displayed several times:

Poznámka

Volání obecných metod vyhledávání se na pohled nijak neliší od volání jejich protějšků, které obecné nejsou, protože jazyky Visual Basic, C# a C++ odvozují parametry obecného typu z typu prvních dvou argumentů.The calls to the generic methods do not look any different from calls to their nongeneric counterparts, because Visual Basic, C#, and C++ infer the type of the generic type parameter from the type of the first two arguments. Použijete-li nástroj Ildasm. exe (IL Disassembler) k prohlédnutí jazyka MSIL (Microsoft Intermediate Language), vidíte, že jsou volány obecné metody.If you use the Ildasm.exe (IL Disassembler) to examine the Microsoft intermediate language (MSIL), you can see that the generic methods are being called.

using namespace System;
using namespace System::Collections::Generic;

public ref class ReverseComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        // Compare y and x in reverse order.
        return y->CompareTo(x);
    }
};

void main()
{
    array<String^>^ dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

    array<int>^ dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes)");
    Array::Sort(dinosaurs, dinosaurSizes);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }

    Console::WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
    Array::Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

    Console::WriteLine();
    for (int i = 0; i < dinosaurs->Length; i++)
    {
        Console::WriteLine("{0}: up to {1} meters long.", 
            dinosaurs[i], dinosaurSizes[i]);
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {
            "Seismosaurus", 
            "Chasmosaurus", 
            "Coelophysis", 
            "Mamenchisaurus", 
            "Caudipteryx", 
            "Cetiosaurus"  };

        int[] dinosaurSizes = { 40, 5, 3, 22, 1, 18 };

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes)");
        Array.Sort(dinosaurs, dinosaurSizes);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }

        Console.WriteLine("\nSort(dinosaurs, dinosaurSizes, 3, 3, rc)");
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc);

        Console.WriteLine();
        for (int i = 0; i < dinosaurs.Length; i++)
        {
            Console.WriteLine("{0}: up to {1} meters long.", 
                dinosaurs[i], dinosaurSizes[i]);
        }
    }
}

/* This code example produces the following output:

Seismosaurus: up to 40 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.

Sort(dinosaurs, dinosaurSizes)

Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.
Coelophysis: up to 3 meters long.
Mamenchisaurus: up to 22 meters long.
Seismosaurus: up to 40 meters long.

Sort(dinosaurs, dinosaurSizes, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Caudipteryx: up to 1 meters long.
Cetiosaurus: up to 18 meters long.
Chasmosaurus: up to 5 meters long.

Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

Seismosaurus: up to 40 meters long.
Mamenchisaurus: up to 22 meters long.
Coelophysis: up to 3 meters long.
Chasmosaurus: up to 5 meters long.
Cetiosaurus: up to 18 meters long.
Caudipteryx: up to 1 meters long.
 */
Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Seismosaurus", _
            "Chasmosaurus", _
            "Coelophysis", _
            "Mamenchisaurus", _
            "Caudipteryx", _
            "Cetiosaurus"  }

        Dim dinosaurSizes() As Integer = { 40, 5, 3, 22, 1, 18 }

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes)")
        Array.Sort(dinosaurs, dinosaurSizes)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

        Console.WriteLine(vbLf & _
            "Sort(dinosaurs, dinosaurSizes, 3, 3, rc)")
        Array.Sort(dinosaurs, dinosaurSizes, 3, 3, rc)

        Console.WriteLine()
        For i As Integer = 0 To dinosaurs.Length - 1
            Console.WriteLine("{0}: up to {1} meters long.", _
                dinosaurs(i), dinosaurSizes(i))
        Next

    End Sub

End Class

' This code example produces the following output:
'
'Seismosaurus: up to 40 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'
'Sort(dinosaurs, dinosaurSizes)
'
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'Coelophysis: up to 3 meters long.
'Mamenchisaurus: up to 22 meters long.
'Seismosaurus: up to 40 meters long.
'
'Sort(dinosaurs, dinosaurSizes, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Caudipteryx: up to 1 meters long.
'Cetiosaurus: up to 18 meters long.
'Chasmosaurus: up to 5 meters long.
'
'Sort(dinosaurs, dinosaurSizes, 3, 3, rc)
'
'Seismosaurus: up to 40 meters long.
'Mamenchisaurus: up to 22 meters long.
'Coelophysis: up to 3 meters long.
'Chasmosaurus: up to 5 meters long.
'Cetiosaurus: up to 18 meters long.
'Caudipteryx: up to 1 meters long.

Poznámky

Každý klíč v keys @ no__t-1 má odpovídající položku v items @ no__t-3.Each key in the keysArray has a corresponding item in the itemsArray. Když se při řazení přemístí klíč, odpovídající položka v items @ no__t-1 se podobně přemístí.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Proto je items @ no__t-1 seřazen podle uspořádání odpovídajících klíčů v keys @ no__t-3.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Pokud je comparer null, každý klíč v zadaném rozsahu prvků v keys @ no__t-3 musí implementovat obecné rozhraní IComparable<T>, aby bylo možné porovnat s každým jiným klíčem.If comparer is null, each key within the specified range of elements in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Řazení lze provést i v případě, že existuje více položek než klíčů, ale položky, jimž neodpovídá žádný klíč, seřazeny nebudou.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Pokud existuje více klíčů než položek, nemůžete řadit. To vyvolá ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Pokud řazení nebylo úspěšně dokončeno, jsou výsledky nedefinované.If the sort is not successfully completed, the results are undefined.

Tato metoda používá následující introspektivní algoritmus řazení (introsort):This method uses the introspective sort (introsort) algorithm as follows:

  • Pokud je velikost oddílu menší než 16 prvků, používá algoritmus řazení vložení .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Pokud počet oddílů překročí 2 * protokoln, kde N je rozsah vstupního pole, používá algoritmů heapsort algoritmus.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • V opačném případě používá quicksort algoritmus.Otherwise, it uses a Quicksort algorithm.

Tato implementace provádí nestabilní řazení, tj. pokud jsou dva prvky shodné, jejich pořadí nemusí zůstat zachováno.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. Stabilní řazení naproti tomu zachovává pořadí prvků se stejnou hodnotou.In contrast, a stable sort preserves the order of elements that are equal.

Pro pole, která jsou seřazená pomocí algoritmů algoritmů heapsort a quicksort, v nejhorším případě je tato metoda operace O (n log n), kde n je length.For arrays that are sorted by using the Heapsort and Quicksort algorithms, in the worst case, this method is an O(n log n) operation, where n is length.

Poznámky pro volající

Rozhraní .NET Framework 4 a starší používala pouze algoritmus quicksort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. Quicksort identifikuje neplatné porovnávače v některých situacích, ve kterých operace řazení vyvolá výjimku IndexOutOfRangeException a vyvolá výjimku ArgumentException volajícímu.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Počínaje .NET Framework 4.5.NET Framework 4.5 je možné, že operace řazení, které dříve vyvolaly ArgumentException, nevyvolají výjimku, protože algoritmů heapsort algoritmy pro řazení a vkládání nerozpoznají neplatnou porovnávací metodu.Starting with the .NET Framework 4.5.NET Framework 4.5, it is possible that sorting operations that previously threw ArgumentException will not throw an exception, because the insertion sort and heapsort algorithms do not detect an invalid comparer. To většinou platí pro pole s méně než 16 prvky.For the most part, this applies to arrays with fewer than 16 elements.

Viz také

Platí pro