Array.Sort 메서드

정의

1차원 배열의 요소를 정렬합니다.Sorts the elements in a one-dimensional array.

오버로드

Sort(Array, Int32, Int32, IComparer)

지정한 Array를 사용하여 1차원 IComparer의 요소 범위에 있는 요소를 정렬합니다.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 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)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

지정한 Array를 사용하여 1차원 IComparer의 요소를 정렬합니다.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Array, IComparer)

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 Array 전체의 요소를 정렬합니다.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

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

지정한 Array 제네릭 인터페이스를 사용하여 IComparer<T>의 요소를 정렬합니다.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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

지정한 Array을 사용하여 Comparison<T>의 요소를 정렬합니다.Sorts the elements in an Array using the specified Comparison<T>.

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

지정한 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[])

각 키의 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>)

지정한 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)

각 키에서 구현하는 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>)

지정한 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)

지정한 Array를 사용하여 1차원 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

정렬할 1차원 Array입니다.The one-dimensional Array to sort.

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

comparer
IComparer

요소를 비교할 때 사용하는 IComparer 구현입니다.The IComparer implementation to use when comparing elements.

또는-or- 각 요소의 IComparable 구현을 사용할 null입니다.null to use the IComparable implementation of each element.

예외

arraynull인 경우array is null.

array가 다차원 배열인 경우array is multidimensional.

indexarray의 하한값보다 작습니다.index is less than the lower bound of array.

또는-or- length가 0보다 작은 경우length is less than zero.

indexlengtharray의 올바른 범위를 지정하지 않습니다.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경우 array의 지정 된 요소 범위 내에 있는 각 요소는 array의 다른 모든 요소와 비교할 수 있도록 IComparable 인터페이스를 구현 해야 합니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

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

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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

정렬할 키를 포함하는 1차원 Array입니다.The one-dimensional Array that contains the keys to sort.

items
Array

keysArray의 각 키에 해당하는 항목을 포함하는 1차원 Array입니다.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

또는-or- keysArray만을 정렬하는 null입니다.null to sort only the keysArray.

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

comparer
IComparer

요소를 비교할 때 사용하는 IComparer 구현입니다.The IComparer implementation to use when comparing elements.

또는-or- 각 요소의 IComparable 구현을 사용할 null입니다.null to use the IComparable implementation of each element.

예외

keysnull인 경우keys is null.

keysArray가 다차원 배열입니다.The keysArray is multidimensional.

또는-or- itemsArray가 다차원 배열입니다.The itemsArray is multidimensional.

indexkeys의 하한값보다 작습니다.index is less than the lower bound of keys.

또는-or- length가 0보다 작은 경우length is less than zero.

itemsnull이 아니고 keys의 하한이 items의 하한과 일치하지 않는 경우items is not null, and the lower bound of keys does not match the lower bound of items.

또는-or- itemsnull이 아니고 keys의 길이가 items의 길이보다 긴 경우items is not null, and the length of keys is greater than the length of items.

또는-or- indexlengthkeysArray의 올바른 범위를 지정하지 않습니다.index and length do not specify a valid range in the keysArray.

또는-or- itemsnull이 아니고 indexlengthitemsArray에서 올바른 범위를 지정하지 않는 경우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


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

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

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

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

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

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

   End Sub


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

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

   End Sub

End Class


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer null되는 경우 keysArray의 지정 된 요소 범위 내에 있는 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

Sort(Array, Int32, Int32)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 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

정렬할 1차원 Array입니다.The one-dimensional Array to sort.

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

예외

arraynull인 경우array is null.

array가 다차원 배열인 경우array is multidimensional.

indexarray의 하한값보다 작습니다.index is less than the lower bound of array.

또는-or- length가 0보다 작은 경우length is less than zero.

indexlengtharray의 올바른 범위를 지정하지 않습니다.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의 지정 된 요소 범위 내에 있는 각 요소는 array의 다른 모든 요소와 비교할 수 있도록 IComparable 인터페이스를 구현 해야 합니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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

정렬할 키를 포함하는 1차원 Array입니다.The one-dimensional Array that contains the keys to sort.

items
Array

keysArray의 각 키에 해당하는 항목을 포함하는 1차원 Array입니다.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

또는-or- keysArray만을 정렬하는 null입니다.null to sort only the keysArray.

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

예외

keysnull입니다.keys is null.

keysArray가 다차원 배열입니다.The keysArray is multidimensional.

또는-or- itemsArray가 다차원 배열입니다.The itemsArray is multidimensional.

indexkeys의 하한값보다 작습니다.index is less than the lower bound of keys.

또는-or- length가 0보다 작은 경우length is less than zero.

itemsnull이 아니고 keys 의 길이가 items의 길이보다 큽니다.items is not null, and the length of keys is greater than the length of items.

또는-or- indexlengthkeysArray의 올바른 범위를 지정하지 않습니다.index and length do not specify a valid range in the keysArray.

또는-or- itemsnull이 아니고 indexlengthitemsArray에서 올바른 범위를 지정하지 않는 경우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


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

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

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

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

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

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

   End Sub


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

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

   End Sub

End Class


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keysArray의 지정 된 요소 범위 내에 있는 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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)

지정한 Array를 사용하여 1차원 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

정렬할 1차원 배열입니다.The one-dimensional array to sort.

comparer
IComparer

요소를 비교할 때 사용하는 구현입니다.The implementation to use when comparing elements.

또는-or- 각 요소의 IComparable 구현을 사용할 null입니다.null to use the IComparable implementation of each element.

예외

arraynull인 경우array is null.

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. 또한 대/소문자를 구분 하지 않는 문자열 비교를 수행 하는 동안 개체의 기본 정렬 순서를 반대로 하는 ReverseComparer 이라는 사용자 지정 IComparer 구현을 정의 합니다.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의 다른 모든 요소와 비교할 수 있도록 IComparable 인터페이스를 구현 해야 합니다.If 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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

Sort(Array, Array, IComparer)

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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

정렬할 키를 포함하는 1차원 Array입니다.The one-dimensional Array that contains the keys to sort.

items
Array

keysArray의 각 키에 해당하는 항목을 포함하는 1차원 Array입니다.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

또는-or- keysArray만을 정렬하는 null입니다.null to sort only the keysArray.

comparer
IComparer

요소를 비교할 때 사용하는 IComparer 구현입니다.The IComparer implementation to use when comparing elements.

또는-or- 각 요소의 IComparable 구현을 사용할 null입니다.null to use the IComparable implementation of each element.

예외

keysnull인 경우keys is null.

keysArray가 다차원 배열입니다.The keysArray is multidimensional.

또는-or- itemsArray가 다차원 배열입니다.The itemsArray is multidimensional.

itemsnull이 아니고 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


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

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

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

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

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

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

   End Sub


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

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

   End Sub

End Class


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer null되는 경우 keysArray의 각 키는 다른 모든 키와 비교할 수 있도록 IComparable 인터페이스를 구현 해야 합니다.If 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n keysLength입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

Sort(Array, Array)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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

정렬할 키를 포함하는 1차원 Array입니다.The one-dimensional Array that contains the keys to sort.

items
Array

keysArray의 각 키에 해당하는 항목을 포함하는 1차원 Array입니다.The one-dimensional Array that contains the items that correspond to each of the keys in the keysArray.

또는-or- keysArray만을 정렬하는 null입니다.null to sort only the keysArray.

예외

keysnull입니다.keys is null.

keysArray가 다차원 배열입니다.The keysArray is multidimensional.

또는-or- itemsArray가 다차원 배열입니다.The itemsArray is multidimensional.

itemsnull이 아니고 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


   Public Shared Sub Main()

      ' Creates and initializes a new Array and a new custom comparer.
      Dim myKeys As [String]() =  {"red", "GREEN", "YELLOW", "BLUE", "purple", "black", "orange"}
      Dim myValues As [String]() =  {"strawberries", "PEARS", "LIMES", "BERRIES", "grapes", "olives", "cantaloupe"}
      Dim myComparer = New myReverserClass()

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

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

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

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

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

   End Sub


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

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

   End Sub

End Class


'This code produces the following output.
'
'The Array initially contains the following values:
'   red       : strawberries
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the default comparer:
'   red       : strawberries
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   YELLOW    : LIMES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting a section of the Array using the reverse case-insensitive comparer:
'   red       : strawberries
'   YELLOW    : LIMES
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   purple    : grapes
'   black     : olives
'   orange    : cantaloupe
'
'After sorting the entire Array using the default comparer:
'   black     : olives
'   BLUE      : BERRIES
'   GREEN     : PEARS
'   orange    : cantaloupe
'   purple    : grapes
'   red       : strawberries
'   YELLOW    : LIMES
'
'After sorting the entire Array using the reverse case-insensitive comparer:
'   YELLOW    : LIMES
'   red       : strawberries
'   purple    : grapes
'   orange    : cantaloupe
'   GREEN     : PEARS
'   BLUE      : BERRIES
'   black     : olives

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keysArray의 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n keysLength입니다.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)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 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

정렬할 1차원 Array입니다.The one-dimensional Array to sort.

예외

arraynull인 경우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의 각 요소는 array의 다른 모든 요소와 비교할 수 있도록 IComparable 인터페이스를 구현 해야 합니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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[])

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[]

정렬할 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array to sort.

예외

arraynull인 경우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.

참고

SortBinarySearch 제네릭 메서드를 호출 하는 것은, C#를 Visual Basic 하 고 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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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 메서드는 비트 보수 (및 시각적 개체 C# C++의 ~ 연산자Xor, 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의 각 요소는 array의 다른 모든 요소와 비교할 수 있도록 IComparable<T> 제네릭 인터페이스를 구현 해야 합니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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>)

지정한 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[]

정렬할 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-base Array to sort

comparer
IComparer<T>

요소를 비교할 때 사용할 IComparer<T> 제네릭 인터페이스 구현이거나 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용할 경우 null입니다.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

예외

arraynull인 경우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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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>) 제네릭 메서드를 호출 하는 것은, C#를 Visual Basic 하 고 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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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 메서드는 비트 보수 (및 시각적 개체 C# C++의 ~ 연산자Xor, 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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

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[]

정렬할 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array to sort

comparison
Comparison<T>

요소를 비교할 때 사용할 Comparison<T>입니다.The Comparison<T> to use when comparing elements.

예외

arraynull인 경우array is null.

또는-or- comparisonnull입니다.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 참조는 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. 이 목록에는 빈 문자열과 null 참조도 포함 됩니다.The list also includes an empty string and a null reference. 이 목록은 CompareDinosByLength 메서드를 나타내는 Comparison<T> 제네릭 대리자를 사용 하 여 정렬 되 고 다시 표시 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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. 대부분의 경우이 값은 6 개 미만의 요소가 포함 된 배열에 적용 됩니다.For the most part, this applies to arrays with less than or equal to 6 elements.

추가 정보

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[]

정렬할 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array to sort

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

예외

arraynull입니다.array is null.

indexarray의 하한값보다 작습니다.index is less than the lower bound of array.

또는-or- length가 0보다 작은 경우length is less than zero.

indexlengtharray의 올바른 범위를 지정하지 않습니다.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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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.

이 코드 예제에서는 세 가지 herbivores 세 개의 carnivores (tyrannosaurids, 정확 하 게)로 구성 된 공룡 이름 배열을 만들고 표시 합니다.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. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) 제네릭 메서드 오버 로드는 ReverseCompare와 함께 사용 되어 마지막 세 요소를 역순으로 정렬 합니다.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. 철저 한 혼동 dinosaurs 다시 표시 됩니다.The thoroughly confused dinosaurs are displayed again.

참고

Sort<T>(T[], IComparer<T>)BinarySearch<T>(T[], T, IComparer<T>) 제네릭 메서드를 호출 하는 것은, C#를 Visual Basic 하 고 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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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>)

지정한 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[]

정렬할 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array to sort.

index
Int32

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

comparer
IComparer<T>

요소를 비교할 때 사용할 IComparer<T> 제네릭 인터페이스 구현이거나 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용할 경우 null입니다.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

예외

arraynull인 경우array is null.

indexarray의 하한값보다 작습니다.index is less than the lower bound of array.

또는-or- length가 0보다 작은 경우length is less than zero.

indexlengtharray의 올바른 범위를 지정하지 않습니다.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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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.

이 코드 예제에서는 세 가지 herbivores 세 개의 carnivores (tyrannosaurids, 정확 하 게)로 구성 된 공룡 이름 배열을 만들고 표시 합니다.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. Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) 제네릭 메서드 오버 로드는 ReverseCompare와 함께 사용 되어 마지막 세 요소를 역순으로 정렬 합니다.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. 철저 한 혼동 dinosaurs 다시 표시 됩니다.The thoroughly confused dinosaurs are displayed again.

참고

Sort<T>(T[], IComparer<T>)BinarySearch<T>(T[], T, IComparer<T>) 제네릭 메서드를 호출 하는 것은, C#를 Visual Basic 하 고 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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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경우 array의 지정 된 요소 범위 내에 있는 각 요소는 array의 다른 모든 요소와 비교할 수 있도록 IComparable<T> 제네릭 인터페이스를 구현 해야 합니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

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[]

정렬할 키를 포함하는 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys의 키에 해당하는 항목을 포함하는 1차원 Array(인덱스는 0부터 시작)이거나 keys만 정렬할 경우 null입니다.The one-dimensional, zero-based Array that contains the items that correspond to the keys in keys, or null to sort only keys.

예외

keysnull인 경우keys is null.

itemsnull이 아니고 keys 의 하한 범위가 items의 하한 범위와 일치하지 않습니다.items is not null, and the lower bound of keys does not match the lower bound of items.

또는-or- itemsnull이 아니고 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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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.

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keysArray의 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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>)

지정한 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[]

정렬할 키를 포함하는 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys의 키에 해당하는 항목을 포함하는 1차원 Array(인덱스는 0부터 시작)이거나 keys만 정렬할 경우 null입니다.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> 제네릭 인터페이스 구현이거나 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용할 경우 null입니다.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

예외

keysnull입니다.keys is null.

itemsnull이 아니고 keys 의 하한 범위가 items의 하한 범위와 일치하지 않습니다.items is not null, and the lower bound of keys does not match the lower bound of items.

또는-or- itemsnull이 아니고 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<f: 602> %60% %28 %60 %600% 5B% 5D% 2C %60 %601% 5B% 5D% 2Ccc% > 7%,Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Generic을 보여 줍니다. 키 및 값을 나타내는 배열 쌍을 정렬 하는 메서드 오버 로드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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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.

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer null되는 경우 keysArray의 각 키는 다른 모든 키와 비교할 수 있도록 IComparable<T> 제네릭 인터페이스를 구현 해야 합니다.If comparer is null, each key in the keysArray must implement the IComparable<T> generic interface to be capable of comparisons with every other key.

키 보다 더 많은 항목이 있는 경우 정렬할 수 있지만 해당 키가 없는 항목은 정렬 되지 않습니다.You can sort if there are more items than keys, but the items that have no corresponding keys will not be sorted. 항목 보다 많은 키가 있는 경우에는 정렬할 수 없습니다. 이렇게 하면 ArgumentException이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 O (n log n) 작업입니다. 여기서 n arrayLength입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

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[]

정렬할 키를 포함하는 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys의 키에 해당하는 항목을 포함하는 1차원 Array(인덱스는 0부터 시작)이거나 keys만 정렬할 경우 null입니다.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

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

예외

keysnull입니다.keys is null.

indexkeys의 하한값보다 작습니다.index is less than the lower bound of keys.

또는-or- length가 0보다 작은 경우length is less than zero.

itemsnull이 아니고 keys의 하한이 items의 하한과 일치하지 않는 경우items is not null, and the lower bound of keys does not match the lower bound of items.

또는-or- itemsnull이 아니고 keys의 길이가 items의 길이보다 긴 경우items is not null, and the length of keys is greater than the length of items.

또는-or- indexlengthkeysArray의 올바른 범위를 지정하지 않습니다.index and length do not specify a valid range in the keysArray.

또는-or- itemsnull이 아니고 indexlengthitemsArray에서 올바른 범위를 지정하지 않는 경우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<f: 601% 60% 602> %28 %60 %600% 5B% 5D% 2C %60%% 5B% 5D% 2CSystem% 2CSystem %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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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.

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

keysArray의 지정 된 요소 범위 내에 있는 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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>)

지정한 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[]

정렬할 키를 포함하는 1차원 Array(인덱스는 0부터 시작)입니다.The one-dimensional, zero-based Array that contains the keys to sort.

items
TValue[]

keys의 키에 해당하는 항목을 포함하는 1차원 Array(인덱스는 0부터 시작)이거나 keys만 정렬할 경우 null입니다.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

정렬할 범위의 시작 인덱스입니다.The starting index of the range to sort.

length
Int32

정렬할 범위에 있는 요소 수입니다.The number of elements in the range to sort.

comparer
IComparer<TKey>

요소를 비교할 때 사용할 IComparer<T> 제네릭 인터페이스 구현이거나 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용할 경우 null입니다.The IComparer<T> generic interface implementation to use when comparing elements, or null to use the IComparable<T> generic interface implementation of each element.

예외

keysnull입니다.keys is null.

indexkeys의 하한값보다 작습니다.index is less than the lower bound of keys.

또는-or- length가 0보다 작은 경우length is less than zero.

itemsnull이 아니고 keys의 하한이 items의 하한과 일치하지 않는 경우items is not null, and the lower bound of keys does not match the lower bound of items.

또는-or- itemsnull이 아니고 keys의 길이가 items의 길이보다 긴 경우items is not null, and the length of keys is greater than the length of items.

또는-or- indexlengthkeysArray의 올바른 범위를 지정하지 않습니다.index and length do not specify a valid range in the keysArray.

또는-or- itemsnull이 아니고 indexlengthitemsArray에서 올바른 범위를 지정하지 않는 경우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<f: 601% 60% 602> %28 %60 %600% 5B% 5D% 2C %60%% 5B% 5D% 2CSystem. Int32% 2CSystem%를 보여 줍니다. 키와 값을 나타내는 배열 쌍을 정렬 하는 데 사용할 2CSystem 및% 7B% 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.

이 코드 예제는 IComparer<string>``IComparer(Of String) (Visual Basic, IComparer<String^> 시각적 개체 C++) 제네릭 인터페이스를 구현 하는 ReverseCompare이라는 문자열에 대 한 대체 비교자를 정의 합니다.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 (IL 디스어셈블러) 를 사용 하 여 MSIL (Microsoft 중간 언어)을 검사 하는 경우 제네릭 메서드가 호출 되는 것을 볼 수 있습니다.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.

설명

keysArray의 각 키에는 itemsArray에 해당 하는 항목이 있습니다.Each key in the keysArray has a corresponding item in the itemsArray. 정렬 하는 동안 키의 위치를 변경 하는 경우 itemsArray의 해당 항목 위치가 유사 하 게 변경 됩니다.When a key is repositioned during the sorting, the corresponding item in the itemsArray is similarly repositioned. 따라서 itemsArraykeysArray의 해당 키 배열에 따라 정렬 됩니다.Therefore, the itemsArray is sorted according to the arrangement of the corresponding keys in the keysArray.

comparer null되는 경우 keysArray의 지정 된 요소 범위 내에 있는 각 키는 다른 모든 키와 비교할 수 있도록 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이 throw 됩니다.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.

이 메서드는 다음과 같이 introsort (내면적인 sort) 알고리즘을 사용 합니다.This method uses the introspective sort (introsort) algorithm as follows:

  • 파티션 크기가 16 개의 요소 보다 작거나 같으면 삽입 정렬 알고리즘을 사용 합니다.If the partition size is less than or equal to 16 elements, it uses an insertion sort algorithm.

  • 파티션 수가 2 * LogN을 초과 하는 경우 n 은 입력 배열의 범위이 고 heapsort 알고리즘을 사용 합니다.If the number of partitions exceeds 2 * LogN, where N is the range of the input array, it uses a Heapsort algorithm.

  • 그렇지 않으면 빠른 정렬 알고리즘을 사용 합니다.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.

Heapsort 및 빠른 정렬 알고리즘을 사용 하 여 정렬 된 배열의 경우 최악의 경우이 메서드는 n length되는 O (n log n) 작업입니다.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 이전 버전에서는 빠른 정렬 알고리즘만 사용 했습니다.The .NET Framework 4 and earlier versions used only the Quicksort algorithm. 빠른 정렬는 정렬 작업에서 IndexOutOfRangeException 예외를 throw 하 고 호출자에 게 ArgumentException 예외를 throw 하는 일부 상황에서 잘못 된 비교자를 식별 합니다.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부터 삽입 정렬 및 heapsort 알고리즘이 잘못 된 비교자를 검색 하지 않으므로 이전에 ArgumentException throw 된 정렬 작업에서 예외를 throw 하지 않을 수 있습니다.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 less than or equal to 16 elements.

추가 정보

적용 대상