Array.Sort Метод

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

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

Параметры

Исключения

Примеры

В следующем примере кода показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения. Сортировки выполняются с помощью средства сравнения по умолчанию и настраиваемого средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class SamplesArray  {

   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }
   }

   public static void Main()  {

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

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

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

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

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

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

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


/*
This code produces the following output.

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

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

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

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

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

*/

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Если comparernull, каждый ключ в указанном диапазоне элементов в keysArray должен реализовать интерфейс IComparable, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

.NET включает предопределенные IComparer реализации, перечисленные в следующей таблице.

Вы также можете поддерживать пользовательские сравнения, предоставив экземпляр собственной реализации IComparer параметру comparer. В этом примере определяется пользовательская реализация IComparer, которая изменяет порядок сортировки по умолчанию и выполняет сравнение строк без учета регистра.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer
• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

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

Параметры

Исключения

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью средства сравнения по умолчанию и пользовательского средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class ReverseComparer : IComparer
{
   // Call CaseInsensitiveComparer.Compare with the parameters reversed.
   public int Compare(Object x, Object y)
   {
       return (new CaseInsensitiveComparer()).Compare(y, x );
   }
}

public class Example
{
   public static void Main()
   {
      // Create and initialize a new array.
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps",
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();

      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);

      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

      // Sort a section of the array using the reverse case-insensitive comparer.
      Array.Sort(words, 1, 3, revComparer);
      Console.WriteLine( "After sorting elements 1-3 by using the reverse case-insensitive comparer:");
      DisplayValues(words);

      // Sort the entire array using the default comparer.
      Array.Sort(words);
      Console.WriteLine( "After sorting the entire array by using the default comparer:");
      DisplayValues(words);

      // Sort the entire array by using the reverse case-insensitive comparer.
      Array.Sort(words, revComparer);
      Console.WriteLine( "After sorting the entire array using the reverse case-insensitive comparer:");
      DisplayValues(words);
   }

   public static void DisplayValues(String[] arr)
   {
      for ( int i = arr.GetLowerBound(0); i <= arr.GetUpperBound(0);
            i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arr[i] );
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    The original order of elements in the array:
//       [0] : The
//       [1] : QUICK
//       [2] : BROWN
//       [3] : FOX
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the default comparer:
//       [0] : The
//       [1] : BROWN
//       [2] : FOX
//       [3] : QUICK
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the reverse case-insensitive comparer:
//       [0] : The
//       [1] : QUICK
//       [2] : FOX
//       [3] : BROWN
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting the entire array by using the default comparer:
//       [0] : BROWN
//       [1] : dog
//       [2] : FOX
//       [3] : jumps
//       [4] : lazy
//       [5] : over
//       [6] : QUICK
//       [7] : the
//       [8] : The
//
//    After sorting the entire array using the reverse case-insensitive comparer:
//       [0] : the
//       [1] : The
//       [2] : QUICK
//       [3] : over
//       [4] : lazy
//       [5] : jumps
//       [6] : FOX
//       [7] : dog
//       [8] : BROWN

Комментарии

Если comparernull, каждый элемент в указанном диапазоне элементов в array должен реализовать интерфейс IComparable, чтобы иметь возможность сравнения с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

.NET включает предопределенные IComparer реализации, перечисленные в следующей таблице.

Вы также можете поддерживать пользовательские сравнения, предоставив экземпляр собственной реализации IComparer параметру comparer. В этом примере определяется класс ReverseComparer, который изменяет порядок сортировки по умолчанию для экземпляров типа и выполняет сравнение строк без учета регистра.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer
• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort (Array keys, Array items, int index, int length);

public static void Sort (Array keys, Array? items, int index, int length);

Параметры

Исключения

Примеры

В следующем примере кода показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения. Сортировки выполняются с помощью средства сравнения по умолчанию и настраиваемого средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class SamplesArray  {

   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }
   }

   public static void Main()  {

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

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

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

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

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

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

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


/*
This code produces the following output.

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

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

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

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

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

*/

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Каждый ключ в заданном диапазоне элементов в keysArray должен реализовать интерфейс IComparable, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

См. также раздел

• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

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

Параметры

Исключения

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью средства сравнения по умолчанию и пользовательского средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class ReverseComparer : IComparer
{
   // Call CaseInsensitiveComparer.Compare with the parameters reversed.
   public int Compare(Object x, Object y)
   {
       return (new CaseInsensitiveComparer()).Compare(y, x );
   }
}

public class Example
{
   public static void Main()
   {
      // Create and initialize a new array.
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps",
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();

      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);

      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

      // Sort a section of the array using the reverse case-insensitive comparer.
      Array.Sort(words, 1, 3, revComparer);
      Console.WriteLine( "After sorting elements 1-3 by using the reverse case-insensitive comparer:");
      DisplayValues(words);

      // Sort the entire array using the default comparer.
      Array.Sort(words);
      Console.WriteLine( "After sorting the entire array by using the default comparer:");
      DisplayValues(words);

      // Sort the entire array by using the reverse case-insensitive comparer.
      Array.Sort(words, revComparer);
      Console.WriteLine( "After sorting the entire array using the reverse case-insensitive comparer:");
      DisplayValues(words);
   }

   public static void DisplayValues(String[] arr)
   {
      for ( int i = arr.GetLowerBound(0); i <= arr.GetUpperBound(0);
            i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arr[i] );
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    The original order of elements in the array:
//       [0] : The
//       [1] : QUICK
//       [2] : BROWN
//       [3] : FOX
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the default comparer:
//       [0] : The
//       [1] : BROWN
//       [2] : FOX
//       [3] : QUICK
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the reverse case-insensitive comparer:
//       [0] : The
//       [1] : QUICK
//       [2] : FOX
//       [3] : BROWN
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting the entire array by using the default comparer:
//       [0] : BROWN
//       [1] : dog
//       [2] : FOX
//       [3] : jumps
//       [4] : lazy
//       [5] : over
//       [6] : QUICK
//       [7] : the
//       [8] : The
//
//    After sorting the entire array using the reverse case-insensitive comparer:
//       [0] : the
//       [1] : The
//       [2] : QUICK
//       [3] : over
//       [4] : lazy
//       [5] : jumps
//       [6] : FOX
//       [7] : dog
//       [8] : BROWN

Комментарии

Каждый элемент в заданном диапазоне элементов в array должен реализовать интерфейс IComparable, который может сравниваться с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

См. также раздел

• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort (Array keys, Array items, System.Collections.IComparer comparer);

public static void Sort (Array keys, Array? items, System.Collections.IComparer? comparer);

Параметры

Исключения

Примеры

В следующем примере показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения. Сортировки выполняются с помощью средства сравнения по умолчанию и настраиваемого средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class SamplesArray  {

   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }
   }

   public static void Main()  {

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

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

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

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

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

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

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


/*
This code produces the following output.

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

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

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

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

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

*/

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Если comparernull, каждый ключ в keysArray должен реализовать интерфейс IComparable для сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

.NET включает предопределенные IComparer реализации, перечисленные в следующей таблице.

Вы также можете поддерживать пользовательские сравнения, предоставив экземпляр собственной реализации IComparer параметру comparer. В этом примере определяется реализация IComparer, которая изменяет порядок сортировки по умолчанию и выполняет сравнение строк без учета регистра.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengthkeys.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer
• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort (Array keys, Array items);

public static void Sort (Array keys, Array? items);

Параметры

Исключения

Примеры

В следующем примере показано, как сортировать два связанных массива, где первый массив содержит ключи, а второй массив содержит значения. Сортировки выполняются с помощью средства сравнения по умолчанию и настраиваемого средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class SamplesArray  {

   public class myReverserClass : IComparer  {

      // Calls CaseInsensitiveComparer.Compare with the parameters reversed.
      int IComparer.Compare( Object x, Object y )  {
          return( (new CaseInsensitiveComparer()).Compare( y, x ) );
      }
   }

   public static void Main()  {

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

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

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

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

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

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

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


/*
This code produces the following output.

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

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

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

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

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

*/

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Каждый ключ в keysArray должен реализовать интерфейс IComparable, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengthkeys.

См. также раздел

• IComparable
• BinarySearch
• IDictionary
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort (Array array);

Параметры

Исключения

Примеры

В следующем примере кода показано, как сортировать значения в Array с помощью средства сравнения по умолчанию и пользовательского средства сравнения, который изменяет порядок сортировки. Обратите внимание, что результат может отличаться в зависимости от текущей CultureInfo.

using System;
using System.Collections;

public class ReverseComparer : IComparer
{
   // Call CaseInsensitiveComparer.Compare with the parameters reversed.
   public int Compare(Object x, Object y)
   {
       return (new CaseInsensitiveComparer()).Compare(y, x );
   }
}

public class Example
{
   public static void Main()
   {
      // Create and initialize a new array.
      String[] words = { "The", "QUICK", "BROWN", "FOX", "jumps",
                         "over", "the", "lazy", "dog" };
      // Instantiate the reverse comparer.
      IComparer revComparer = new ReverseComparer();

      // Display the values of the array.
      Console.WriteLine( "The original order of elements in the array:" );
      DisplayValues(words);

      // Sort a section of the array using the default comparer.
      Array.Sort(words, 1, 3);
      Console.WriteLine( "After sorting elements 1-3 by using the default comparer:");
      DisplayValues(words);

      // Sort a section of the array using the reverse case-insensitive comparer.
      Array.Sort(words, 1, 3, revComparer);
      Console.WriteLine( "After sorting elements 1-3 by using the reverse case-insensitive comparer:");
      DisplayValues(words);

      // Sort the entire array using the default comparer.
      Array.Sort(words);
      Console.WriteLine( "After sorting the entire array by using the default comparer:");
      DisplayValues(words);

      // Sort the entire array by using the reverse case-insensitive comparer.
      Array.Sort(words, revComparer);
      Console.WriteLine( "After sorting the entire array using the reverse case-insensitive comparer:");
      DisplayValues(words);
   }

   public static void DisplayValues(String[] arr)
   {
      for ( int i = arr.GetLowerBound(0); i <= arr.GetUpperBound(0);
            i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arr[i] );
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    The original order of elements in the array:
//       [0] : The
//       [1] : QUICK
//       [2] : BROWN
//       [3] : FOX
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the default comparer:
//       [0] : The
//       [1] : BROWN
//       [2] : FOX
//       [3] : QUICK
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting elements 1-3 by using the reverse case-insensitive comparer:
//       [0] : The
//       [1] : QUICK
//       [2] : FOX
//       [3] : BROWN
//       [4] : jumps
//       [5] : over
//       [6] : the
//       [7] : lazy
//       [8] : dog
//
//    After sorting the entire array by using the default comparer:
//       [0] : BROWN
//       [1] : dog
//       [2] : FOX
//       [3] : jumps
//       [4] : lazy
//       [5] : over
//       [6] : QUICK
//       [7] : the
//       [8] : The
//
//    After sorting the entire array using the reverse case-insensitive comparer:
//       [0] : the
//       [1] : The
//       [2] : QUICK
//       [3] : over
//       [4] : lazy
//       [5] : jumps
//       [6] : FOX
//       [7] : dog
//       [8] : BROWN

Комментарии

Каждый элемент array должен реализовать интерфейс IComparable, чтобы иметь возможность сравнения с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

См. также раздел

• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort (Array array, System.Collections.IComparer comparer);

public static void Sort (Array array, System.Collections.IComparer? comparer);

Параметры

Исключения

Примеры

В следующем примере сортируются значения в строковом массиве с помощью средства сравнения по умолчанию. Он также определяет пользовательскую реализацию IComparer с именем ReverseComparer, которая изменяет порядок сортировки объекта по умолчанию при выполнении сравнения строк без учета регистра. Обратите внимание, что выходные данные могут отличаться в зависимости от текущего языка и региональных параметров.

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

Комментарии

Если comparernull, каждый элемент array должен реализовать интерфейс IComparable для сравнения с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

.NET включает предопределенные IComparer реализации, перечисленные в следующей таблице.

Вы также можете поддерживать пользовательские сравнения, предоставив экземпляр собственной реализации IComparer параметру comparer. В этом примере определяется класс ReverseComparer, который изменяет порядок сортировки по умолчанию для экземпляров типа и выполняет сравнение строк без учета регистра.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer
• IComparable
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<T> (T[] array);

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

Параметры

Исключения

Примеры

В следующем примере кода демонстрируется перегрузка универсального метода Sort<T>(T[]) и перегрузка универсального метода BinarySearch<T>(T[], T). Массив строк создается без определенного порядка.

Массив отображается, сортируется и отображается снова.

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

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

Комментарии

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

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

См. также раздел

• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<T> (T[] array, System.Collections.Generic.IComparer<T> comparer);

public static void Sort<T> (T[] array, System.Collections.Generic.IComparer<T>? comparer);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

Массив отображается, сортируется и отображается снова. Для использования метода BinarySearch необходимо отсортировать массивы.

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

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

Комментарии

Если comparernull, каждый элемент array должен реализовать универсальный интерфейс IComparable<T> для сравнения с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer<T>
• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<T> (T[] array, Comparison<T> comparison);

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

Параметры

Исключения

Примеры

В следующем примере кода демонстрируется перегрузка метода Sort(Comparison<T>).

В примере кода определяется альтернативный метод сравнения строк с именем CompareDinosByLength. Этот метод работает следующим образом: во-первых, сравнения проверяются дляnull, а ссылка null обрабатывается как меньше, чем значение NULL. Во-вторых, длина строки сравнивается, а длинная строка считается большей. В-третьих, если длина равна, используется обычное сравнение строк.

Массив строк создается и заполняется четырьмя строками без определенного порядка. Список также содержит пустую строку и ссылку null. Список отображается, отсортирован с помощью Comparison<T> универсального делегата, представляющего метод CompareDinosByLength, и отображается снова.

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

Комментарии

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм introspective (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 6 элементам.

См. также раздел

• Comparison<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<T> (T[] array, int index, int length);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров, состоящий из трех травоядных, за которыми следует три плотоядных (тираннозауриды, чтобы быть точным). Перегрузка универсального метода Sort<T>(T[], Int32, Int32) используется для сортировки последних трех элементов массива, который затем отображается. Перегрузка универсального метода Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется ReverseCompare для сортировки последних трех элементов в обратном порядке. Тщательно запутанные динозавры отображаются снова.

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

Комментарии

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

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

См. также раздел

• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<T> (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);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров, состоящий из трех травоядных, за которыми следует три плотоядных (тираннозауриды, чтобы быть точным). Перегрузка универсального метода Sort<T>(T[], Int32, Int32) используется для сортировки последних трех элементов массива, который затем отображается. Перегрузка универсального метода Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется ReverseCompare для сортировки последних трех элементов в обратном порядке. Тщательно запутанные динозавры отображаются снова.

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

Комментарии

Если comparernull, каждый элемент в заданном диапазоне элементов в array должен реализовать универсальный интерфейс IComparable<T>, чтобы иметь возможность сравнения с каждым другим элементом в array.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer<T>
• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<TKey,TValue> (TKey[] keys, 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);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string>(IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров (ключи) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения). Затем массивы сортируются и отображаются несколько раз:

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[]) используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) и экземпляр ReverseCompare используются для изменения порядка сортировки парных массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) используется для сортировки последних трех элементов обоих массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется для сортировки последних трех элементов обоих массивов в обратном порядке.

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

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Если comparernull, каждый ключ в указанном диапазоне элементов в keysArray должен реализовать универсальный интерфейс IComparable<T>, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer<T>
• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items);

public static void Sort<TKey,TValue> (TKey[] keys, TValue[]? items);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров (ключи) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения). Затем массивы сортируются и отображаются несколько раз:

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[]) используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) и экземпляр ReverseCompare используются для изменения порядка сортировки парных массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) используется для сортировки последних трех элементов обоих массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется для сортировки последних трех элементов обоих массивов в обратном порядке.

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

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Каждый ключ в keysArray должен реализовать универсальный интерфейс IComparable<T>, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

См. также раздел

• IComparable<T>
• BinarySearch
• IDictionary<TKey,TValue>
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, System.Collections.Generic.IComparer<TKey> comparer);

public static void Sort<TKey,TValue> (TKey[] keys, TValue[]? items, System.Collections.Generic.IComparer<TKey>? comparer);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров (ключи) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения). Затем массивы сортируются и отображаются несколько раз:

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[]) используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) и экземпляр ReverseCompare используются для изменения порядка сортировки парных массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) используется для сортировки последних трех элементов обоих массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется для сортировки последних трех элементов обоих массивов в обратном порядке.

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

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Если comparernull, каждый ключ в keysArray должен реализовать универсальный интерфейс IComparable<T> для сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n ), где n является Lengtharray.

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

.NET Framework 4 и более ранние версии использовали только алгоритм Quicksort. Quicksort определяет недопустимые компраторы в некоторых ситуациях, в которых операция сортировки создает исключение IndexOutOfRangeException и вызывает исключение ArgumentException вызывающей стороны. Начиная с .NET Framework 4.5, возможно, что операции сортировки, которые ранее бросили ArgumentException, не будут вызывать исключение, так как алгоритмы сортировки вставки и кучи не обнаруживают недопустимого сравнения. В большинстве случаев это относится к массивам с меньшей или равной 16 элементам.

См. также раздел

• IComparer<T>
• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах

Исходный код:

Array.cs

Исходный код:

Array.cs

Исходный код:

Array.cs

public static void Sort<TKey,TValue> (TKey[] keys, TValue[] items, int index, int length);

public static void Sort<TKey,TValue> (TKey[] keys, TValue[]? items, int index, int length);

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

Параметры

Исключения

Примеры

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

В примере кода определяется альтернативный средство сравнения строк с именем ReverseCompare, реализующее универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++). Средство сравнения вызывает метод CompareTo(String), возвращая порядок сравнения таким образом, чтобы строки сортируются высоко к низкому, а не низкому.

В примере кода создается и отображается массив имен динозавров (ключи) и массив целых чисел, представляющих максимальную длину каждого динозавра в метрах (значения). Затем массивы сортируются и отображаются несколько раз:

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[]) используется для сортировки обоих массивов в порядке имен динозавров в первом массиве.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) и экземпляр ReverseCompare используются для изменения порядка сортировки парных массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) используется для сортировки последних трех элементов обоих массивов.

• Перегрузка Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) используется для сортировки последних трех элементов обоих массивов в обратном порядке.

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

Комментарии

Каждый ключ в keysArray имеет соответствующий элемент в itemsArray. При перепозиции ключа во время сортировки соответствующий элемент в itemsArray изменяется аналогично. Поэтому itemsArray сортируется в соответствии с расположением соответствующих ключей в keysArray.

Каждый ключ в указанном диапазоне элементов в keysArray должен реализовать универсальный интерфейс IComparable<T>, чтобы иметь возможность сравнения с каждым другим ключом.

Можно сортировать, если есть больше элементов, чем ключи, но элементы, у которых нет соответствующих ключей, не будут отсортированы. Невозможно отсортировать, если есть больше ключей, чем элементы; при этом возникает ArgumentException.

Если сортировка не выполнена успешно, результаты не определены.

Этот метод использует алгоритм интроспективной сортировки (introsort) следующим образом:

• Если размер секции меньше или равен 16 элементам, он использует алгоритм сортировки вставки.

• Если число секций превышает 2 * Журнал^N, где N — это диапазон входного массива, он использует алгоритм Heapsort.

• В противном случае используется алгоритм Quicksort.

Эта реализация выполняет неустойчивую сортировку; То есть, если два элемента равны, их порядок может не сохраняться. В отличие от этого, стабильная сортировка сохраняет порядок элементов, равных.

Этот метод представляет собой операцию nжурнала O(n), где nlength.

См. также раздел

• IComparable<T>
• BinarySearch
• выполнение Culture-Insensitive строковых операций в массивах