En este post voy a mostrar cómo ordenar arreglos en C# de manera ascendente y descendente usando un Comparison y llamando al método Array.Sort, además de usar CompareTo para comparar los valores.

De esta manera se podrán ordenar arreglos de tipo string, double, float, int, etcétera.

Algoritmos

Si quieres usar algoritmos propios te invito a ver el método de la burbuja en C# y también el método de quicksort.

Comparison y el método CompareTo en C#

Si no quieres leer la teoría, sigue bajando hasta que encuentres el código.

Para entender cómo se ordenan los arreglos (lo que indica si se ordenan de manera ascendente o descendente)  hay que conocer el método CompareTo que devuelve 3 posibles valores: -1, 0 y 1

Devuelve -1 si el primer valor es menor que el segundo, 0 si son iguales y uno si el primero es mayor que el segundo.

Esto lo indicamos en un Comparison en donde pasamos la función que va a indicar cómo se ordena el arreglo, dicha función requiere que se devuelva 1, 0 o -1 y por lo tanto usamos CompareTo que ya lo hace por sí mismo.

Después todo es cosa de llamar a Array.Sort pasándole el arreglo y el comparador.

Ordenar arreglo de tipo int en C#

Veamos cómo ordenar un arreglo de enteros. Podríamos comparar usando el operador == pero mejor usamos CompareTo pues nos ahorra código.

Ascendente

Por defecto, Array.Sort ordena de manera ascendente sin que se lo indiquemos, pero de igual manera le pasamos el comparador para ser explícitos.

/*
 Ordenar arreglo de tipo int
 de manera ascendente
*/using System;

class MainClass {
  public static void Main (string[] args) {
 // Arreglo desordenado
 int[] numeros = {50, 8, 96, 200, 13, 123, 1, 1, 23, 3, 54, 51};
 // Crear un comparador que ordena de manera ascendente
 Comparison<int> comparador = new Comparison<int>((numero1, numero2) => numero1.CompareTo(numero2));
 // Llamar a Array.Sort, pasando el arreglo a ordenar y el comparador
 Array.Sort<int>(numeros, comparador);
 // Ahora simplemente imprimimos
 foreach(int numero in numeros){
  Console.WriteLine(numero);
 }
  }
}

Es importante notar que no llamamos a un método del arreglo, sino que simplemente pasamos el arreglo como variable a Array.Sort, el cual lo modificará de manera interna.

Descendente

Lo único que cambia es el comparador, pues ahora compara el segundo número con el primero. El código es como se ve a continuación:

/*
 Ordenar arreglo de tipo int
 de manera descendente en C#
*/using System;

class MainClass {
 public static void Main (string[] args) {
  // Arreglo desordenado
  int[] numeros = {50, 8, 96, 200, 13, 123, 1, 1, 23, 3, 54, 51};
  // Crear un comparador que ordena de manera descendente,
  // solo intercambiamos el orden de comparación
  Comparison<int> comparador = new Comparison<int>((numero1, numero2) => numero2.CompareTo(numero1));
  // Llamar a Array.Sort, pasando el arreglo a ordenar y el comparador
  Array.Sort<int>(numeros, comparador);
  // Ahora simplemente imprimimos
  foreach(int numero in numeros){
   Console.WriteLine(numero);
  }
 }
}

Ya lo dije, al invertir el orden de comparación el arreglo queda ordenado de mayor a menor.

Arreglos de cadena

El método CompareTo también funciona en las cadenas y las compara de manera alfabética de tal manera que “a” es menor que “b“; “alma” es menor que “arma” (porque la l va antes de la r) y “Zaira” es mayor que “Ana“.

Igualmente creamos un comparador y llamamos a Array.Sort pero indicamos que todo será de tipo string.

Ascendente

El código que ordena un arreglo de strings de manera ascendente es el siguiente:

using System;

class MainClass {
 public static void Main (string[] args) {
  // Arreglo desordenado
  string[] canciones = {
   "Drive in saturday",
   "Ziggy stardust",
   "Let's spend the night together",
   "Hang on to yourself",
   "Ashes to ashes",
   "Moonage daydream",
  };
  // Crear un comparador que ordena de manera ascendente,
  // usando CompareTo en las cadenas, lo cual compara alfabéticamente
  Comparison<string> comparador = new Comparison<string>((cadena1, cadena2) => cadena1.CompareTo(cadena2));
  // Llamar a Array.Sort, pasando el arreglo a ordenar y el comparador
  Array.Sort<string>(canciones, comparador);
  // Ahora simplemente imprimimos
  foreach(string cancion in canciones){
   Console.WriteLine(cancion);
  }
 }
}

Si ambas cadenas son iguales las pondrá una después de otra, no va a eliminar nada. Lo mismo pasa con los demás tipos de datos.

Descendente

Invertimos la forma en la que se realiza la comparación de las cadenas y el código es el siguiente:

using System;

class MainClass {
  public static void Main (string[] args) {
  // Arreglo desordenado
  string[] canciones = {
   "Drive in saturday",
   "Ziggy stardust",
   "Let's spend the night together",
   "Hang on to yourself",
   "Ashes to ashes",
   "Moonage daydream",
  };
  // Crear un comparador que ordena de manera descendente 
  // (comparamos cadena2 con cadena1, no al revés),
  // usando CompareTo en las cadenas, lo cual compara alfabéticamente
  Comparison<string> comparador = new Comparison<string>((cadena1, cadena2) => cadena2.CompareTo(cadena1));
  // Llamar a Array.Sort, pasando el arreglo a ordenar y el comparador
  Array.Sort<string>(canciones, comparador);
  // Ahora simplemente imprimimos
  foreach(string cancion in canciones){
       Console.WriteLine(cancion);
  }
  }
}

La ejecución del código se ve en la siguiente imagen:

Otros tipos de datos como long, float o double

Los métodos Array.Sort y CompareTo funcionan de igual manera para estos tipos de datos; solamente haría falta especificar el tipo de dato en cada implementación.

Más ejercicios de C#: Click aquí.