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

 

Publicado: octubre de 2016

Ordena los elementos de un intervalo de elementos de una matriz Array unidimensional mediante el uso de la implementación de IComparable de cada elemento de la matriz Array.

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

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

Parámetros

array
Type: System.Array

Array unidimensional que se va a ordenar.

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 array es null.

RankException

array es multidimensional.

ArgumentOutOfRangeException

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

-o-

length es menor que cero.

ArgumentException

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

InvalidOperationException

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

Cada elemento dentro del intervalo especificado de elementos de array debe implementar la IComparable para realizar comparaciones con los demás elementos de interfaz de array.

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 los valores de un Array 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 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    

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: