Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.Sort (Array, Array, Int32, Int32)

 

Publicado: octubre de 2016

Ordena un intervalo de elementos en un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la implementación de IComparable de cada clave.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

keys
Type: System.Array

La Array unidimensional que contiene las claves que se van a ordenar.

items
Type: System.Array

La Array unidimensional que contiene los elementos que se corresponden con cada una de las claves de keysArray.

-o-

null para ordenar solo las keysArray.

index
Type: System.Int32

Índice inicial del intervalo que se va a ordenar.

length
Type: System.Int32

Número de elementos del intervalo que se va a ordenar.

Exception Condition
ArgumentNullException

El valor de keys es null.

RankException

keys Array es multidimensional.

-o-

La itemsArray es multidimensional.

ArgumentOutOfRangeException

index es menor que el límite inferior de keys.

-o-

length es menor que cero.

ArgumentException

items no es null y la longitud de keys es mayor que la longitud de items.

-o-

index y length no especifican un intervalo válido en keysArray.

-o-

items no es null y index y length no especifican un intervalo válido en itemsArray.

InvalidOperationException

Uno o más elementos de las keysArray no implementan la interfaz IComparable.

Cada clave de la keysArray tiene un elemento correspondiente en el itemsArray. Cuando se cambia la posición de una clave durante la ordenación, el elemento correspondiente de la itemsArray se vuelve a colocar de forma similar. Por lo tanto, la itemsArray se ordenan en función de la organización de las claves correspondientes en el keysArray.

Cada clave dentro del intervalo especificado de elementos de la keysArray debe implementar la IComparable interfaz para poder realizar comparaciones con todas las demás claves.

Puede ordenar si hay más elementos que las claves, pero no se ordenará los elementos que no tengan ninguna de las claves correspondientes. No se puede ordenar si hay más teclas que elementos; al hacerlo se inicia una ArgumentException.

Si la ordenación no se ha completado correctamente, los resultados son indefinidos.

Este método utiliza el algoritmo de ordenación introspectivas (introsort) como se indica a continuación:

  • Si el tamaño de partición es menos de 16 elementos, usa un insertion sort algoritmo.

  • Si el número de particiones superior a 2 * registroN, donde N es el intervalo de la matriz de entrada, utiliza un Heapsort algoritmo.

  • De lo contrario, usa un Quicksort algoritmo.

Esta implementación realiza a una ordenación inestable; es decir, si dos elementos son iguales, puede que no se conserve su orden. En cambio, una ordenación estable conserva el orden de los elementos que son iguales.

Para las matrices que se ordenan mediante el uso de los algoritmos Heapsort y Quicksort, en el peor de los casos, este método es una O (n registro n) operación, donde n es length.

En el ejemplo de código siguiente se muestra cómo ordenar dos matrices asociadas, donde la primera matriz que contiene las claves y la segunda matriz contiene los valores. Ordenaciones se realizan utilizando el comparador predeterminado y un comparador personalizado que invierte el criterio de ordenación. Tenga en cuenta que el resultado puede variar según la actual 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

*/

Plataforma universal de Windows
Disponible desde 10
.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: