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

Определение

Сортирует элементы в одномерном массиве.Sorts the elements in a one-dimensional array.

Перегрузки

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

Сортирует элементы в диапазоне элементов одномерного массива Array, используя заданный интерфейс 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)

Сортирует диапазон элементов в паре одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный интерфейс 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)

Сортирует элементы в диапазоне элементов одномерного массива Array с помощью реализации интерфейса IComparable каждого элемента массива 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)

Сортирует диапазон элементов в паре одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию интерфейса 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)

Сортирует элементы в одномерном массиве Array, используя заданный интерфейс 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)

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный интерфейс 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)

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию интерфейса 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)

Сортирует элементы во всем одномерном массиве Array, используя реализацию интерфейса IComparable каждого элемента массива 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[])

Сортирует элементы во всем массиве Array, используя реализацию универсального интерфейса IComparable<T> каждого элемента массива 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>)

Сортирует элементы в одномерном массиве Array, используя заданный универсальный интерфейс 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>)

Сортирует элементы массива Array с использованием указанного объекта 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)

Сортирует элементы в диапазоне элементов массива Array, используя реализацию универсального интерфейса IComparable<T> каждого элемента массива 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>)

Сортирует элементы в диапазоне элементов массива Array, используя заданный универсальный интерфейс 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[])

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию универсального интерфейса IComparable<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 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>)

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный универсальный интерфейс 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)

Сортирует диапазон элементов в паре объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию универсального интерфейса IComparable<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 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>)

Сортирует диапазон элементов в паре объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный универсальный интерфейс 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)

Сортирует элементы в диапазоне элементов одномерного массива Array, используя заданный интерфейс 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

Параметры

array
Array Array Array Array

Одномерный массив Array для сортировки.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Реализация интерфейса IComparer, которая используется при сравнении элементов.The IComparer implementation to use when comparing elements.

- или --or- Значение null для использования реализации IComparable каждого элемента.null to use the IComparable implementation of each element.

Исключения

Свойство array имеет значение null.array is null.

Массив array является многомерным.array is multidimensional.

index меньше нижней границы массива array.index is less than the lower bound of array.

- или --or- Значение параметра length меньше нуля.length is less than zero.

index и length не указывают допустимый диапазон в array.index and length do not specify a valid range in array.

-или--or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре array не реализуют интерфейс IComparable.comparer is null, and one or more elements in array do not implement the IComparable interface.

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.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. Обратите внимание, что результат может отличаться в зависимости от 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

Комментарии

Если comparer имеет nullзначение, каждый элемент в пределах указанного IComparable диапазона элементов в array должен реализовывать интерфейс, чтобы иметь возможность сравнения с любым другим элементом в 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.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

.NET Framework включает стандартные IComparer реализации, перечисленные в следующей таблице.The .NET Framework includes predefined IComparer implementations listed in the following table.

РеализацияImplementation ОписаниеDescription
System.Collections.CaseInsensitiveComparer Сравнивает все два объекта, но выполняет сравнение строк без учета регистра.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Сравнивает все два объекта с помощью правил сортировки текущего языка и региональных параметров.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Сравнивает все два объекта, используя соглашения о сортировке инвариантного языка и региональных параметров.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Сравнивает два объекта типа T , используя порядок сортировки по умолчанию для типа.Compares two objects of type T by using the type's default sort order.

Можно также поддерживать пользовательские сравнения, предоставляя IComparer comparer для параметра экземпляр собственной реализации.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Этот пример делает это путем определения ReverseComparer класса, который изменяет порядок сортировки по умолчанию для экземпляров типа и выполняет сравнение строк без учета регистра.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.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует диапазон элементов в паре одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный интерфейс 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)

Параметры

keys
Array Array Array Array

Одномерный массив Array, содержащий ключи для сортировки.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Одномерный массив Array, который содержит элементы, соответствующие ключам в массиве Arraykeys.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- или --or- Значение null для сортировки только массива Arraykeys.null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

comparer
IComparer IComparer IComparer IComparer

Реализация интерфейса IComparer, которая используется при сравнении элементов.The IComparer implementation to use when comparing elements.

-или--or- Значение null для использования реализации IComparable каждого элемента.null to use the IComparable implementation of each element.

Исключения

Свойство keys имеет значение null.keys is null.

keysArray является многомерным.The keysArray is multidimensional.

- или --or- itemsArray является многомерным.The itemsArray is multidimensional.

index меньше нижней границы массива keys.index is less than the lower bound of keys.

- или --or- Значение параметра length меньше нуля.length is less than zero.

Значение параметра items не равно null, а нижняя граница массива keys не совпадает с нижней границей массива items.items is not null, and the lower bound of keys does not match the lower bound of items.

- или --or- Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

- или --or- index и length не определяют допустимый диапазон в keysArray.index and length do not specify a valid range in the keysArray.

- или --or- Значение параметра items не равно null, а параметры index и length не определяют допустимый диапазон в массиве itemsArray.items is not null, and index and length do not specify a valid range in the itemsArray.

-или--or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре keysArray не реализуют интерфейс IComparable.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Примеры

В следующем примере кода показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения.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. Сортировка выполняется с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Обратите внимание, что результат может отличаться в зависимости от 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 'myReverserClass


   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 'SamplesArray


'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

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Если comparer имеет nullзначение, каждый ключ в пределах Array указанного keys диапазона элементов IComparable в необходимо реализовать интерфейс для сравнения с любым другим ключом.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.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

.NET Framework включает стандартные IComparer реализации, перечисленные в следующей таблице.The .NET Framework includes predefined IComparer implementations listed in the following table.

РеализацияImplementation ОписаниеDescription
System.Collections.CaseInsensitiveComparer Сравнивает все два объекта, но выполняет сравнение строк без учета регистра.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Сравнивает все два объекта с помощью правил сортировки текущего языка и региональных параметров.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Сравнивает все два объекта, используя соглашения о сортировке инвариантного языка и региональных параметров.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Сравнивает два объекта типа T , используя порядок сортировки по умолчанию для типа.Compares two objects of type T by using the type's default sort order.

Можно также поддерживать пользовательские сравнения, предоставляя IComparer comparer для параметра экземпляр собственной реализации.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. В этом примере определяется пользовательская IComparer реализация, которая изменяет порядок сортировки по умолчанию и выполняет сравнение строк без учета регистра.The example does this by defining a custom IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует элементы в диапазоне элементов одномерного массива Array с помощью реализации интерфейса IComparable каждого элемента массива 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

Параметры

array
Array Array Array Array

Одномерный массив Array для сортировки.The one-dimensional Array to sort.

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

Исключения

Свойство array имеет значение null.array is null.

Массив array является многомерным.array is multidimensional.

index меньше нижней границы массива array.index is less than the lower bound of array.

-или--or- Значение параметра length меньше нуля.length is less than zero.

index и length не указывают допустимый диапазон в array.index and length do not specify a valid range in array.

Один или несколько элементов в массиве array не реализуют интерфейс IComparable.One or more elements in array do not implement the IComparable interface.

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.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. Обратите внимание, что результат может отличаться в зависимости от 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

Комментарии

Каждый элемент в пределах указанного диапазона элементов в array должен IComparable реализовывать интерфейс, чтобы иметь возможность сравнения с любым другим элементом в 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.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Дополнительно

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

Сортирует диапазон элементов в паре одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию интерфейса 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)

Параметры

keys
Array Array Array Array

Одномерный массив Array, содержащий ключи для сортировки.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Одномерный массив Array, который содержит элементы, соответствующие ключам в массиве Arraykeys.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- или --or- Значение null для сортировки только массива Arraykeys.null to sort only the keysArray.

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

Исключения

keysArray является многомерным.The keysArray is multidimensional.

- или --or- itemsArray является многомерным.The itemsArray is multidimensional.

index меньше нижней границы массива keys.index is less than the lower bound of keys.

-или--or- Значение параметра length меньше нуля.length is less than zero.

items не равно null, а длина keys больше длины items.items is not null, and the length of keys is greater than the length of items.

- или --or- index и length не определяют допустимый диапазон в keysArray.index and length do not specify a valid range in the keysArray.

- или --or- Значение параметра items не равно null, а параметры index и length не определяют допустимый диапазон в массиве itemsArray.items is not null, and index and length do not specify a valid range in the itemsArray.

Один или несколько элементов в массиве keysArray не реализуют интерфейс IComparable.One or more elements in the keysArray do not implement the IComparable interface.

Примеры

В следующем примере кода показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения.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. Сортировка выполняется с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Обратите внимание, что результат может отличаться в зависимости от 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 'myReverserClass


   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 'SamplesArray


'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

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Каждый ключ в пределах указанного диапазона элементов в keys Array должен реализовывать IComparable интерфейс, чтобы иметь возможность сравнения с любым другим ключом.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.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Дополнительно

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

Сортирует элементы в одномерном массиве Array, используя заданный интерфейс 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

Параметры

array
Array Array Array Array

Одномерный массив для сортировки.The one-dimensional array to sort.

comparer
IComparer IComparer IComparer IComparer

Реализация интерфейса, которая используется при сравнении элементов.The implementation to use when comparing elements.

- или --or- Значение null для использования реализации IComparable каждого элемента.null to use the IComparable implementation of each element.

Исключения

Массив array является многомерным.array is multidimensional.

Значение параметра comparernull, а один или несколько элементов в параметре array не реализуют интерфейс IComparable.comparer is null, and one or more elements in array do not implement the IComparable interface.

Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Примеры

В следующем примере значения в массиве строк сортируются с помощью компаратора по умолчанию.The following example sorts the values in a string array by using the default comparer. Он также определяет пользовательскую IComparer реализацию с ReverseComparer именем, которая изменяет порядок сортировки по умолчанию объекта при выполнении сравнения строк без учета регистра.It also defines a custom IComparer implementation named ReverseComparer that reverses an object's default sort order while performing a case-insensitive string comparison. Обратите внимание, что выходные данные могут различаться в зависимости от текущего языка и региональных параметров.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

Комментарии

Если comparer имеет nullзначение, каждый array arrayэлемент должен реализовывать интерфейс, чтобы иметь возможность сравнения с любым другим элементом в. IComparableIf comparer is null, each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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 включает стандартные IComparer реализации, перечисленные в следующей таблице.The .NET Framework includes predefined IComparer implementations listed in the following table.

РеализацияImplementation ОписаниеDescription
System.Collections.CaseInsensitiveComparer Сравнивает все два объекта, но выполняет сравнение строк без учета регистра.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Сравнивает все два объекта с помощью правил сортировки текущего языка и региональных параметров.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Сравнивает все два объекта, используя соглашения о сортировке инвариантного языка и региональных параметров.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Сравнивает два объекта типа T , используя порядок сортировки по умолчанию для типа.Compares two objects of type T by using the type's default sort order.

Можно также поддерживать пользовательские сравнения, предоставляя IComparer comparer для параметра экземпляр собственной реализации.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Этот пример делает это путем определения ReverseComparer класса, который изменяет порядок сортировки по умолчанию для экземпляров типа и выполняет сравнение строк без учета регистра.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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный интерфейс 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)

Параметры

keys
Array Array Array Array

Одномерный массив Array, содержащий ключи для сортировки.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Одномерный массив Array, который содержит элементы, соответствующие ключам в массиве Arraykeys.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- или --or- Значение null для сортировки только массива Arraykeys.null to sort only the keysArray.

comparer
IComparer IComparer IComparer IComparer

Реализация интерфейса IComparer, которая используется при сравнении элементов.The IComparer implementation to use when comparing elements.

- или --or- Значение null для использования реализации IComparable каждого элемента.null to use the IComparable implementation of each element.

Исключения

Свойство keys имеет значение null.keys is null.

keysArray является многомерным.The keysArray is multidimensional.

-или--or- itemsArray является многомерным.The itemsArray is multidimensional.

Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

- или --or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре keysArray не реализуют интерфейс IComparable.comparer is null, and one or more elements in the keysArray do not implement the IComparable interface.

Примеры

В следующем примере показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Сортировка выполняется с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Обратите внимание, что результат может отличаться в зависимости от 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 'myReverserClass


   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 'SamplesArray


'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

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Если comparer имеет nullзначение ,каждыйIComparable ключ в долженреализовыватьинтерфейс,чтобыиметьвозможностьсравненияслюбымдругимключом.Array keysIf comparer is null, each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

.NET Framework включает стандартные IComparer реализации, перечисленные в следующей таблице.The .NET Framework includes predefined IComparer implementations listed in the following table.

РеализацияImplementation ОписаниеDescription
System.Collections.CaseInsensitiveComparer Сравнивает все два объекта, но выполняет сравнение строк без учета регистра.Compares any two objects, but performs a case-insensitive comparison of strings.
Comparer.Default Сравнивает все два объекта с помощью правил сортировки текущего языка и региональных параметров.Compares any two objects by using the sorting conventions of the current culture.
Comparer.DefaultInvariant Сравнивает все два объекта, используя соглашения о сортировке инвариантного языка и региональных параметров.Compares any two objects by using the sorting conventions of the invariant culture.
Comparer<T>.Default Сравнивает два объекта типа T , используя порядок сортировки по умолчанию для типа.Compares two objects of type T by using the type's default sort order.

Можно также поддерживать пользовательские сравнения, предоставляя IComparer comparer для параметра экземпляр собственной реализации.You can also support custom comparisons by providing an instance of your own IComparer implementation to the comparer parameter. Этот пример делает это путем определения IComparer реализации, которая изменяет порядок сортировки по умолчанию и выполняет сравнение строк без учета регистра.The example does this by defining an IComparer implementation that reverses the default sort order and performs case-insensitive string comparison.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию интерфейса 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)

Параметры

keys
Array Array Array Array

Одномерный массив Array, содержащий ключи для сортировки.The one-dimensional Array that contains the keys to sort.

items
Array Array Array Array

Одномерный массив Array, который содержит элементы, соответствующие ключам в массиве Arraykeys.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

- или --or- Значение null для сортировки только массива Arraykeys.null to sort only the keysArray.

Исключения

Свойство keys имеет значение null.keys is null.

keysArray является многомерным.The keysArray is multidimensional.

- или --or- itemsArray является многомерным.The itemsArray is multidimensional.

Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

Один или несколько элементов в массиве keysArray не реализуют интерфейс IComparable.One or more elements in the keysArray do not implement the IComparable interface.

Примеры

В следующем примере показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения.The following example shows how to sort two associated arrays where the first array contains the keys and the second array contains the values. Сортировка выполняется с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.Sorts are done using the default comparer and a custom comparer that reverses the sort order. Обратите внимание, что результат может отличаться в зависимости от 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 'myReverserClass


   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 'SamplesArray


'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

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Каждый ключ в keys Array должен реализовывать IComparable интерфейс, чтобы иметь возможность сравнения с любым другим ключом.Each key in the keysArray must implement the IComparable interface to be capable of comparisons with every other key.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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.

Дополнительно

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

Сортирует элементы во всем одномерном массиве Array, используя реализацию интерфейса IComparable каждого элемента массива 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

Параметры

array
Array Array Array Array

Одномерный массив Array для сортировки.The one-dimensional Array to sort.

Исключения

Свойство array имеет значение null.array is null.

Массив array является многомерным.array is multidimensional.

Один или несколько элементов в массиве array не реализуют интерфейс IComparable.One or more elements in array do not implement the IComparable interface.

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью компаратора по умолчанию и пользовательского компаратора, который изменяет порядок сортировки на обратный.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. Обратите внимание, что результат может отличаться в зависимости от 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

Комментарии

Каждый элемент array должен IComparable реализовывать интерфейс, чтобы иметь возможность сравнения с любым другим элементом в array.Each element of array must implement the IComparable interface to be capable of comparisons with every other element in array.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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.

Дополнительно

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

Сортирует элементы во всем массиве Array, используя реализацию универсального интерфейса IComparable<T> каждого элемента массива 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())

Параметры типа

T

Тип элементов массива.The type of the elements of the array.

Параметры

array
T[]

Сортируемый одномерный массив Array, индексация которого начинается с нуля.The one-dimensional, zero-based Array to sort.

Исключения

Свойство array имеет значение null.array is null.

Один или несколько элементов в массиве array не реализуют универсальный интерфейс IComparable<T>.One or more elements in array do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода демонстрируется Sort<T>(T[]) перегрузка универсального метода 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. Создается массив строк без определенного порядка.An array of strings is created, in no particular order.

Массив отображается, сортируется и отображается снова.The array is displayed, sorted, and displayed again.

Примечание

Вызовы Sort универсальных методов и BinarySearch не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первого аргумента. .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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Перегрузка BinarySearch<T>(T[], T) универсального метода затем используется для поиска двух строк, которые не находятся в массиве, а другая —.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. Массив и возвращаемое значение BinarySearch метода передаются ShowWhere в универсальный метод, который отображает значение индекса, если строка найдена, и в противном случае элементы, которые строка поиска попадают в массив.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. ShowWhere Индекс является отрицательным, если строка не является n массивом, поэтому метод принимает побитовое дополнение (оператор ~ в C# и Visual C++, Xor -1 в Visual Basic), чтобы получить индекс первого элемента в списке, который больше, чем Строка поиска.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.

Комментарии

Каждый элемент array должен IComparable<T> реализовывать универсальный интерфейс, чтобы иметь возможность сравнения с любым другим элементом в array.Each element of array must implement the IComparable<T> generic interface to be capable of comparisons with every other element in array.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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.

Дополнительно

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

Сортирует элементы в одномерном массиве Array, используя заданный универсальный интерфейс 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))

Параметры типа

T

Тип элементов массива.The type of the elements of the array.

Параметры

array
T[]

Сортируемый одномерный массив Array, индексация которого начинается с нуля.The one-dimensional, zero-base Array to sort

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

Реализация универсального интерфейса IComparer<T>, используемая при сравнении элементов, или значение null для использования реализации универсального интерфейса IComparable<T> каждого элемента.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Исключения

Свойство array имеет значение null.array is null.

Значение параметра comparernull, а один или несколько элементов в параметре array не реализуют универсальный интерфейс IComparable<T>.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Примеры

В следующем примере кода демонстрируется Sort<T>(T[], IComparer<T>) перегрузка универсального метода 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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

Массив отображается, сортируется и отображается снова.The array is displayed, sorted, and displayed again. Массивы должны быть отсортированы, чтобы можно BinarySearch было использовать метод.Arrays must be sorted in order to use the BinarySearch method.

Примечание

Вызовы Sort<T>(T[], IComparer<T>) универсальных методов и BinarySearch<T>(T[], T, IComparer<T>) не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первого аргумента. .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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Перегрузка BinarySearch<T>(T[], T, IComparer<T>) универсального метода затем используется для поиска двух строк, которые не находятся в массиве, а другая —.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. Массив и возвращаемое значение BinarySearch<T>(T[], T, IComparer<T>) метода передаются ShowWhere в универсальный метод, который отображает значение индекса, если строка найдена, и в противном случае элементы, которые строка поиска попадают в массив.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. ShowWhere Индекс является отрицательным, если строка не является n массивом, поэтому метод принимает побитовое дополнение (оператор ~ в C# и Visual C++, Xor -1 в Visual Basic), чтобы получить индекс первого элемента в списке, который больше, чем Строка поиска.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.

Комментарии

Если comparer имеет nullзначение, каждый array arrayэлемент должен реализовывать универсальный интерфейс, чтобы иметь возможность сравнения с любым другим элементом в. IComparable<T>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.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует элементы массива Array с использованием указанного объекта 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))

Параметры типа

T

Тип элементов массива.The type of the elements of the array.

Параметры

array
T[]

Сортируемый одномерный массив Array, индексация которого начинается с нуля.The one-dimensional, zero-based Array to sort

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

Comparison<T>, используемый при сравнении элементов.The Comparison<T> to use when comparing elements.

Исключения

Свойство array имеет значение null.array is null.

-или--or- Свойство comparison имеет значение null.comparison is null.

Реализация comparison вызвала ошибку во время сортировки.The implementation of comparison caused an error during the sort. Например, comparison может не возвратить 0 при сравнении элемента с самим собой.For example, comparison might not return 0 when comparing an item with itself.

Примеры

В следующем примере кода показана Sort(Comparison<T>) перегрузка метода.The following code example demonstrates the Sort(Comparison<T>) method overload.

В примере кода определяется альтернативный метод сравнения для строк с именем CompareDinosByLength.The code example defines an alternative comparison method for strings, named CompareDinosByLength. Этот метод работает следующим образом: Во-первых, сравниваемые проверяются наnull, а пустая ссылка считается меньше, чем значение, отличное от NULL.This method works as follows: First, the comparands are tested fornull, and a null reference is treated as less than a non-null. Во-вторых, длины строк сравниваются, а более длинная строка считается большей.Second, the string lengths are compared, and the longer string is deemed to be greater. В-третьих, если длины равны, используется обычное сравнение строк.Third, if the lengths are equal, ordinary string comparison is used.

Массив строк создается и заполняется четырьмя строками без определенного порядка.A array of strings is created and populated with four strings, in no particular order. Список также содержит пустую строку и пустую ссылку.The list also includes an empty string and a null reference. Список отображается, сортируется с помощью Comparison<T> универсального делегата, CompareDinosByLength представляющего метод, и снова отображается.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"

Комментарии

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует элементы в диапазоне элементов массива Array, используя реализацию универсального интерфейса IComparable<T> каждого элемента массива 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)

Параметры типа

T

Тип элементов массива.The type of the elements of the array.

Параметры

array
T[]

Сортируемый одномерный массив Array, индексация которого начинается с нуля.The one-dimensional, zero-based Array to sort

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

Исключения

Свойство array имеет значение null.array is null.

index меньше нижней границы массива array.index is less than the lower bound of array.

-или--or- Значение параметра length меньше нуля.length is less than zero.

index и length не указывают допустимый диапазон в array.index and length do not specify a valid range in array.

Один или несколько элементов в массиве array не реализуют универсальный интерфейс IComparable<T>.One or more elements in array do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода показана Sort<T>(T[], Int32, Int32) перегрузка универсального метода Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) и перегрузка универсального метода для сортировки диапазона в массиве.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров, состоящий из трех хербиворес, за которыми следуют три карниворес (тиранносауридс, чтобы быть точными).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Перегрузка Sort<T>(T[], Int32, Int32) универсального метода используется для сортировки последних трех элементов массива, которые затем отображаются.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Перегрузка универсального метода используется с ReverseCompare для сортировки последних трех элементов в обратном порядке. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)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. Все эти динозавры снова отображаются.The thoroughly confused dinosaurs are displayed again.

Примечание

Вызовы Sort<T>(T[], IComparer<T>) универсальных методов и BinarySearch<T>(T[], T, IComparer<T>) не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первого аргумента. .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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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

Комментарии

Каждый элемент в пределах указанного диапазона элементов в array должен IComparable<T> реализовывать универсальный интерфейс, чтобы иметь возможность сравнения с любым другим элементом в 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.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Дополнительно

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

Сортирует элементы в диапазоне элементов массива Array, используя заданный универсальный интерфейс 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))

Параметры типа

T

Тип элементов массива.The type of the elements of the array.

Параметры

array
T[]

Сортируемый одномерный массив Array, индексация которого начинается с нуля.The one-dimensional, zero-based Array to sort.

index
Int32 Int32 Int32 Int32

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

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

Реализация универсального интерфейса IComparer<T>, используемая при сравнении элементов, или значение null для использования реализации универсального интерфейса IComparable<T> каждого элемента.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Исключения

index меньше нижней границы массива array.index is less than the lower bound of array.

-или--or- Значение параметра length меньше нуля.length is less than zero.

index и length не указывают допустимый диапазон в array.index and length do not specify a valid range in array.

-или--or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре array не реализуют универсальный интерфейс IComparable<T>.comparer is null, and one or more elements in array do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода показана Sort<T>(T[], Int32, Int32) перегрузка универсального метода Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) и перегрузка универсального метода для сортировки диапазона в массиве.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров, состоящий из трех хербиворес, за которыми следуют три карниворес (тиранносауридс, чтобы быть точными).The code example creates and displays an array of dinosaur names, consisting of three herbivores followed by three carnivores (tyrannosaurids, to be precise). Перегрузка Sort<T>(T[], Int32, Int32) универсального метода используется для сортировки последних трех элементов массива, которые затем отображаются.The Sort<T>(T[], Int32, Int32) generic method overload is used to sort the last three elements of the array, which is then displayed. Перегрузка универсального метода используется с ReverseCompare для сортировки последних трех элементов в обратном порядке. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)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. Все эти динозавры снова отображаются.The thoroughly confused dinosaurs are displayed again.

Примечание

Вызовы Sort<T>(T[], IComparer<T>) универсальных методов и BinarySearch<T>(T[], T, IComparer<T>) не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первого аргумента. .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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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

Комментарии

Если comparer имеет nullзначение, каждый элемент в пределах указанного IComparable<T> диапазона элементов в array должен реализовывать универсальный интерфейс, чтобы иметь возможность сравнения с каждым другим элементом в 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.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию универсального интерфейса IComparable<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 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())

Параметры типа

TKey

Тип элементов массива ключей.The type of the elements of the key array.

TValue

Тип элементов массива элементов.The type of the elements of the items array.

Параметры

keys
TKey[]

Индексируемый от нуля одномерный массив Array, содержащий ключи для сортировки.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Индексируемый от нуля одномерный массив Array, содержащий элементы, соответствующие ключам в массиве keys, или значение null для сортировки только массива keys.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

Исключения

items не равно null, а нижняя граница массива keys не соответствует нижней границе массива items.items is not null, and the lower bound of keys does not match the lower bound of items.

- или --or- Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

Один или несколько элементов в массиве keysArray не реализуют универсальный интерфейс IComparable<T>.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода демонстрируются Sort<TKey,TValue>(TKey[], TValue[])перегрузки универсальных методов, Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)и Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) , для сортировки пар массивов, представляющих ключи и значения.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров (ключей) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения).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). Затем массивы сортируются и отображаются несколько раз:The arrays are then sorted and displayed several times:

Примечание

Вызовы универсальных методов не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первых двух аргументов.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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Каждый ключ в keys Array должен реализовывать IComparable<T> универсальный интерфейс, чтобы иметь возможность сравнения с любым другим ключом.Each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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.

Дополнительно

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

Сортирует пару одномерных объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный универсальный интерфейс 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))

Параметры типа

TKey

Тип элементов массива ключей.The type of the elements of the key array.

TValue

Тип элементов массива элементов.The type of the elements of the items array.

Параметры

keys
TKey[]

Индексируемый от нуля одномерный массив Array, содержащий ключи для сортировки.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Индексируемый от нуля одномерный массив Array, содержащий элементы, соответствующие ключам в массиве keys, или значение null для сортировки только массива 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>

Реализация универсального интерфейса IComparer<T>, используемая при сравнении элементов, или значение null для использования реализации универсального интерфейса IComparable<T> каждого элемента.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Исключения

items не равно null, а нижняя граница массива keys не соответствует нижней границе массива items.items is not null, and the lower bound of keys does not match the lower bound of items.

-или--or- Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

-или--or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре keysArray не реализуют универсальный интерфейс IComparable<T>.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Примеры

В следующем 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), и Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) перегрузки универсальных методов для сортировки пар массивов, представляющих ключи и значения.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров (ключей) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения).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). Затем массивы сортируются и отображаются несколько раз:The arrays are then sorted and displayed several times:

  • Sort<TKey,TValue>(TKey[], TValue[]) Перегрузка используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.The Sort<TKey,TValue>(TKey[], TValue[]) overload is used to sort both arrays in order of the dinosaur names in the first array.

  • Для изменения]порядка сортировки<используется [, TValue XREF: System. Array. Sort% 60% 602% 28%,%,%, 601% 5b%,%. Collections. Generic. IComparer% 7b% 60% 600% 7D% 29 >, и экземпляр класса ReverseCompare . пары массивов.The [], 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> overload and an instance of ReverseCompare are used to reverse the sort order of the paired arrays.

  • Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Перегрузка используется для сортировки последних трех элементов обоих массивов.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) overload is used to sort the last three elements of both arrays.

  • Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Перегрузка используется для сортировки последних трех элементов обоих массивов в противоположном порядке.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload is used to sort the last three elements of both arrays in reverse order.

Примечание

Вызовы универсальных методов не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первых двух аргументов.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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Если comparer имеет nullзначение ,каждыйIComparable<T> ключ в долженреализовыватьуниверсальныйинтерфейс,чтобыиметьвозможностьсравненияслюбымдругимключом.Array keysIf comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшемn случае этот метод является Length операцией O (log n), где n — из 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 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

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)

Сортирует диапазон элементов в паре объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя реализацию универсального интерфейса IComparable<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 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)

Параметры типа

TKey

Тип элементов массива ключей.The type of the elements of the key array.

TValue

Тип элементов массива элементов.The type of the elements of the items array.

Параметры

keys
TKey[]

Индексируемый от нуля одномерный массив Array, содержащий ключи для сортировки.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Индексируемый от нуля одномерный массив Array, содержащий элементы, соответствующие ключам в массиве keys, или значение null для сортировки только массива 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

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

Исключения

Свойство keys имеет значение null.keys is null.

index меньше нижней границы массива keys.index is less than the lower bound of keys.

- или --or- Значение параметра length меньше нуля.length is less than zero.

Значение параметра items не равно null, а нижняя граница массива keys не совпадает с нижней границей массива items.items is not null, and the lower bound of keys does not match the lower bound of items.

- или --or- Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

- или --or- index и length не определяют допустимый диапазон в keysArray.index and length do not specify a valid range in the keysArray.

- или --or- Значение параметра items не равно null, а параметры index и length не определяют допустимый диапазон в массиве itemsArray.items is not null, and index and length do not specify a valid range in the itemsArray.

Один или несколько элементов в массиве keysArray не реализуют универсальный интерфейс IComparable<T>.One or more elements in the keysArray do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода показаны 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 > и Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) универсальные перегрузки метода для сортировки пар массивов, представляющих ключи и значения.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string> реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров (ключей) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения).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). Затем массивы сортируются и отображаются несколько раз:The arrays are then sorted and displayed several times:

  • Sort<TKey,TValue>(TKey[], TValue[]) Перегрузка используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.The Sort<TKey,TValue>(TKey[], TValue[]) overload is used to sort both arrays in order of the dinosaur names in the first array.

  • Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Перегрузка иReverseCompare экземпляр используются для изменения порядка сортировки парных массивов.The Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) overload and an instance of ReverseCompare are used to reverse the sort order of the paired arrays.

  • Для сортировки]последних трех<элементов обоих массивов используется перегрузка [, TValue XREF: System. Array. Sort% 60% 602% 28%,% 3% 5b%,% 3,% 5B% 2CSystem. Int32% 2CSystem. Int32% 29 >.The [], TValue<xref:System.Array.Sort%60%602%28%60%600%5B%5D%2C%60%601%5B%5D%2CSystem.Int32%2CSystem.Int32%29> overload is used to sort the last three elements of both arrays.

  • Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Перегрузка используется для сортировки последних трех элементов обоих массивов в противоположном порядке.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) overload is used to sort the last three elements of both arrays in reverse order.

Примечание

Вызовы универсальных методов не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первых двух аргументов.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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Каждый ключ в пределах указанного диапазона элементов в keys Array должен реализовывать IComparable<T> универсальный интерфейс, чтобы иметь возможность сравнения с любым другим ключом.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.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Дополнительно

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

Сортирует диапазон элементов в паре объектов Array (один содержит ключи, а другой — соответствующие элементы) по ключам в первом массиве Array, используя заданный универсальный интерфейс 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))

Параметры типа

TKey

Тип элементов массива ключей.The type of the elements of the key array.

TValue

Тип элементов массива элементов.The type of the elements of the items array.

Параметры

keys
TKey[]

Индексируемый от нуля одномерный массив Array, содержащий ключи для сортировки.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

Индексируемый от нуля одномерный массив Array, содержащий элементы, соответствующие ключам в массиве keys, или значение null для сортировки только массива 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

Начальный индекс диапазона сортировки.The starting index of the range to sort.

length
Int32 Int32 Int32 Int32

Число элементов в диапазоне сортировки.The number of elements in the range to sort.

comparer
IComparer<TKey>

Реализация универсального интерфейса IComparer<T>, используемая при сравнении элементов, или значение null для использования реализации универсального интерфейса IComparable<T> каждого элемента.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

Исключения

Свойство keys имеет значение null.keys is null.

index меньше нижней границы массива keys.index is less than the lower bound of keys.

-или--or- Значение параметра length меньше нуля.length is less than zero.

Значение параметра items не равно null, а нижняя граница массива keys не совпадает с нижней границей массива items.items is not null, and the lower bound of keys does not match the lower bound of items.

-или--or- Значение параметра items не равно null, и длина параметра keys больше длины параметра items.items is not null, and the length of keys is greater than the length of items.

- или --or- index и length не определяют допустимый диапазон в keysArray.index and length do not specify a valid range in the keysArray.

- или --or- Значение параметра items не равно null, а параметры index и length не определяют допустимый диапазон в массиве itemsArray.items is not null, and index and length do not specify a valid range in the itemsArray.

- или --or- Реализация comparer вызвала ошибку во время сортировки.The implementation of comparer caused an error during the sort. Например, comparer может не возвратить 0 при сравнении элемента с самим собой.For example, comparer might not return 0 when comparing an item with itself.

Значение параметра comparernull, а один или несколько элементов в параметре keysArray не реализуют универсальный интерфейс IComparable<T>.comparer is null, and one or more elements in the keysArray do not implement the IComparable<T> generic interface.

Примеры

В следующем примере кода показаны Sort<TKey,TValue>(TKey[], TValue[]), Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)и [], 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 > универсальные перегрузки метода для сортировки пар массивов, представляющих ключи и значения.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.

В примере кода определяется альтернативное средство сравнения для строк с именем ReverseCompare, которое IComparer<string>реализует универсальный интерфейсIComparer(Of String) (в Visual Basic IComparer<String^> , в C++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. Функция сравнения вызывает CompareTo(String) метод, отменяя порядок сравниваемых значений, чтобы строки были в высоком и низком уровне, а не в высоком.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.

В примере кода создается и отображается массив названий динозавров (ключей) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения).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). Затем массивы сортируются и отображаются несколько раз:The arrays are then sorted and displayed several times:

  • Sort<TKey,TValue>(TKey[], TValue[]) Перегрузка используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.The Sort<TKey,TValue>(TKey[], TValue[]) overload is used to sort both arrays in order of the dinosaur names in the first array.

  • Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Перегрузка иReverseCompare экземпляр используются для изменения порядка сортировки парных массивов.The Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) overload and an instance of ReverseCompare are used to reverse the sort order of the paired arrays.

  • Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Перегрузка используется для сортировки последних трех элементов обоих массивов.The Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) overload is used to sort the last three elements of both arrays.

  • Объект [], TValue<XREF: System. Array. Sort% 60% 602% 28%,% 3% 5b% 5D% 2c% 60% 601% 5b% 5D% 2CSystem. Int32% 2CSystem. Int32% 2CSystem. Collections. Generic. IComparer% 7b% 60% 600% 7D% 29 > используется для сортировки последних трех элементы обоих массивов в обратном порядке.The [], 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> overload is used to sort the last three elements of both arrays in reverse order.

Примечание

Вызовы универсальных методов не отличаются от вызовов к неуниверсальным аналогам, поскольку Visual Basic, C#и C++ определяют тип параметра универсального типа из типа первых двух аргументов.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. Если вы используете Ildasm. exe , чтобы изучить MSIL, можно увидеть, что вызываемые универсальные методы вызываются.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.

Комментарии

Каждый keys ключ в Array имеет соответствующий элемент в items Array.Each key in the keysArray has a corresponding item in the itemsArray. При перемещении ключа во время сортировки соответствующий элемент в items Array будет перемещен соответствующим образом.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. Таким образом, items Array сортируется в соответствии с расположением соответствующих ключей в keys. ArrayTherefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

Если comparer имеет nullзначение, каждый ключ в пределах Array указанного keys диапазона элементов IComparable<T> в необходимо реализовать универсальный интерфейс для сравнения с любым другим ключом.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.

Если число элементов больше, чем ключей, можно выполнить сортировку, но элементы, не имеющие соответствующих ключей, не будут отсортированы.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. Невозможно выполнить сортировку, если количество ключей превышает число элементов; При этом создается исключение ArgumentException.You cannot sort if there are more keys than items; doing this throws an ArgumentException.

Если сортировка не выполнена успешно, результаты будут неопределенными.If the sort is not successfully completed, the results are undefined.

Этот метод использует алгоритм сортировки гибридности (интросорт) следующим образом:This method uses the introspective sort (introsort) algorithm as follows:

  • Если размер секции меньше 16 элементов, он использует алгоритм сортировки вставки .If the partition size is fewer than 16 elements, it uses an insertion sort algorithm.

  • Если количество секций превышает 2 * logn, где n — это диапазон входного массива, используется алгоритм хеапсорт .If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • В противном случае используется алгоритм QuickSort .Otherwise, it uses a Quicksort algorithm.

Эта реализация выполняет нестабильную сортировку; то есть, если два элемента равны, их порядок может не сохраняться.This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.In contrast, a stable sort preserves the order of elements that are equal.

Для массивов, отсортированных с помощью алгоритмов хеапсорт и QuickSort, в худшем случае этот метод является операцией O (n log n), где n имеет значение 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.

Примечания для тех, кто вызывает этот метод

В .NET Framework 4 и более ранних версиях использовался только алгоритм QuickSort.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. QuickSort определяет недопустимые компараторы в некоторых ситуациях, в которых операция сортировки IndexOutOfRangeException создает исключение, и ArgumentException создает исключение для вызывающего объекта.Quicksort identifies invalid comparers in some situations in which the sorting operation throws an IndexOutOfRangeException exception, and throws an ArgumentException exception to the caller. Начиная с .NET Framework 4.5.NET Framework 4.5, возможно, операции сортировки, которые ArgumentException раньше создавали исключение, не вызовут исключения, так как алгоритмы сортировки и хеапсорт не обнаруживают недопустимый компаратор.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. В большинстве случаев это относится к массивам, количество элементов в которых меньше 16.For the most part, this applies to arrays with fewer than 16 elements.

Дополнительно

Применяется к