Introducción a la clasificación en C #
Ordenar en C # es el proceso de organizar el contenido de una colección en un orden específico. Una colección puede ser una matriz, una lista o cualquier otro grupo de datos. La colección puede contener elementos de tipos simples, así como tipos complejos. Un tipo simple puede ser una colección de enteros, cadenas, números de coma flotante, etc. Un tipo complejo puede ser una colección de objetos de tipos definidos por el usuario, como Empleado, Estudiante, etc. Los tipos complejos están anidados con mayor frecuencia. Los objetos pueden tener múltiples atributos.
Ejemplos
- Tipo simple
- Colección de enteros: (1, 2, 3, 4, 5)
- Colección de cuerdas - ("Mark", "Jamie", "Anna")
- Tipo complejo
- ((Nombre: "Marca", Identificación del empleado: "123", Oficina: "Londres"),
(Nombre: "Jane", Identificación del empleado: "456", Oficina: "NY"),
(Nombre: "Annie", Identificación del empleado: "789", Oficina: "Sydney"))
- ((Nombre: "Marca", Identificación del empleado: "123", Oficina: "Londres"),
C # ha proporcionado métodos integrados para ordenar colecciones. Ya sea una matriz, una lista o cualquier colección genérica, el método C # Sort () puede ordenarlo según el comparador proporcionado. Internamente, la implementación .Net usa el algoritmo Quicksort para ordenar colecciones en C #. Discutiremos más sobre esto en las secciones posteriores del artículo.
¿Cómo se realiza la clasificación en C #?
Como se indicó anteriormente, el marco .Net utiliza el enfoque Quicksort para ordenar los elementos en una colección C #. Entonces, ¿qué es quicksort?
Quicksort sigue una estrategia de divide y vencerás. Esto significa que el algoritmo de clasificación selecciona un elemento pivote y divide la matriz en función del elemento pivote. Los elementos más pequeños que el pivote se colocan delante de él. Los elementos más grandes que el pivote se colocan después de él. Esto asegura que el elemento pivote esté ordenado. Además, la matriz se divide en dos elementos: más pequeños que el pivote y elementos más grandes que el pivote. A continuación, el algoritmo sigue el mismo enfoque para ambas matrices.
Una ilustración de esto se puede ver a continuación.
Matriz sin clasificar : 18, 5, 16, 23, 50, 32
Paso 1 (Pivote = 32) - 18, 5, 16, 23, 32, 50
Paso 2a
Matriz sin clasificar - 18, 5, 16, 23
Pivote = 23
Matriz parcialmente ordenada: 18, 5, 16, 23
Paso 2b
Matriz sin clasificar - 50
Pivote = 50
Matriz parcialmente ordenada - 50
Paso 3a
Matriz sin clasificar - 18, 5, 16
Pivote = 16
Matriz parcialmente ordenada - 5, 16, 18
Matriz ordenada: 5, 16, 18, 23, 32, 50
Por lo tanto, Quicksort tiene dos procesos clave: seleccionar el pivote y particionar la matriz. Las implementaciones del algoritmo dependen de la selección del pivote. Puede ser el primer elemento, o el último, o cualquier elemento aleatorio, o la mediana de la matriz. Una vez que se realiza la partición y el pivote se coloca en la posición correcta, el algoritmo se llama de forma recursiva para las matrices particionadas, hasta que se ordene cada elemento.
Cuando la clasificación se realiza en C #, surge el concepto de Quicksort estable e inestable. En un Quicksort estable, si dos elementos son iguales, se conserva su orden de la matriz original. De lo contrario, está en una clasificación rápida inestable. La implementación de C # utiliza Quicksort inestable.
Tipos de clasificación en C #
En esta sección del artículo, nos centraremos principalmente en dos tipos de colecciones en C #: matrices y listas. Profundizaríamos en cómo C # clasifica las matrices y las listas. La siguiente sección trataría de explicarlo con algunos ejemplos.
1. Ordenar una matriz en C #
Veamos las diferentes formas en que podemos ordenar una matriz en C #.
a. Usar el comparador predeterminado
Este es el método predeterminado de Ordenar (). Si ningún Comparer se pasa explícitamente al método, C # usa el orden ascendente para organizar los elementos.
Código:
using System;
public class Program
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
int() intArray = (23, 76, 12, 43, 90, 30);
Array.Sort(strArray);
Array.Sort(intArray);
Console.WriteLine("Sorted String Array:\n");
DisplayArray(strArray);
Console.WriteLine("\n\n\nSorted Integer Array:\n");
DisplayArray(intArray);
)
static void DisplayArray(string() arr)
(
foreach (string a in arr)
(
Console.Write(a + "\t");
)
)
static void DisplayArray(int() arr)
(
foreach (int a in arr)
(
Console.Write(a + "\t");
)
)
)
Salida:
si. Usando el comparador personalizado
También podemos proporcionar nuestro propio Comparer personalizado al método Sort (). Esto indicaría al compilador de C # que use el comparador personalizado en lugar del predeterminado.
Para crear un comparador personalizado, necesitamos implementar el método Compare () desde la interfaz IComparer. El siguiente código muestra cómo crear un comparador que ordenaría los elementos en orden descendente.
Creamos una clase, la heredamos de la interfaz IComparer, implementamos el método Compare () y lo anulamos para comparar los elementos en orden descendente.
Código:
using System;
public class DescendingComparer : System.Collections.IComparer
(
public int Compare(Object a, Object b)
(
return (new System.Collections.CaseInsensitiveComparer()).Compare(b, a);
)
)
public class Program
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
int() intArray = (23, 76, 12, 43, 90, 30);
Array.Sort(strArray, new DescendingComparer());
Array.Sort(intArray, new DescendingComparer());
Console.WriteLine("Sorted String Array in Descending Order:\n");
DisplayArray(strArray);
Console.WriteLine("\n\n\nSorted Integer Array in Desc Order:\n");
DisplayArray(intArray);
)
static void DisplayArray(string() arr)
(
foreach (string a in arr)
(
Console.Write(a + "\t");
)
)
static void DisplayArray(int() arr)
(
foreach (int a in arr)
(
Console.Write(a + "\t");
)
)
)
Salida:
C. Usando pares clave-valor
C # también proporciona una forma de ordenar una matriz utilizando valores clave de otra matriz. El siguiente ejemplo tiene pares clave-valor de nombres y apellidos de personas. Los ordenaríamos por nombre y apellido usando el método Sort ().
Código:
using System;
public class Program
(
public static void Main()
(
String() firstNames = ("Tom", "Jack", "Anna", "Veronica", "Jessica", "Mike");
String() lastNames = ("Phelps", "Anderson", "Spectre", "Clarke", "Williams", "Fonseca");
Array.Sort(firstNames, lastNames);
Console.WriteLine("Sorted by First Names:\n");
DisplayArray(firstNames, lastNames);
Array.Sort(lastNames, firstNames);
Console.WriteLine("\n\nSorted by Last Names:\n");
DisplayArray(firstNames, lastNames);
)
static void DisplayArray(string() arr1, string() arr2)
(
for (int i = 0; i < arr1.Length; i++)
(
Console.WriteLine(arr1(i) + " " + arr2(i));
)
)
)
Salida:
2. Ordenar una lista en C #
Veamos las diferentes formas en que podemos ordenar una lista en C #.
Nota : Para usar Listas en C #, incluida la biblioteca System.Collections.Generic.a. Usar el comparador predeterminado
Este es el método predeterminado sort (). si no se pasa ningún comparador explícitamente al método, c # usa el orden ascendente para organizar los elementos.
Código:
public class Program
using System.Collections.Generic;
(
public static void Main()
(
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
List strList = new List(strArray);
int() intArray = (23, 76, 12, 43, 90, 30);
List intList = new List(intArray);
strList.Sort();
intList.Sort();
Console.WriteLine("Sorted String List:\n");
DisplayList(strList);
Console.WriteLine("\n\n\nSorted Integer List:\n");
DisplayList(intList);
)
static void DisplayList(List myList)
(
foreach (string a in myList)
(
Console.Write(a + "\t");
)
)
static void DisplayList(List myList)
(
foreach (int a in myList)
(
Console.Write(a + "\t");
)
)
)
Salida:
si. Usando el comparador personalizado
También podemos proporcionar nuestro propio comparador personalizado al método sort (). Esto indicaría al compilador de C # que use el comparador personalizado en lugar del predeterminado.
Para crear un comparador personalizado, necesitamos implementar el método Compare () desde la interfaz IComparer. El siguiente código muestra cómo crear un comparador que ordenaría los elementos en orden descendente.
Creamos una clase, la heredamos de la interfaz IComparer, implementamos el método Compare () y lo anulamos para comparar los elementos en orden descendente.
Código:
using System;
using System.Collections.Generic;
public class LengthComparer : IComparer
(
public int Compare(string a, string b)
(
return (a.Length.CompareTo(b.Length));
)
)
public class DigitSumComparer : IComparer
(
public int Compare(int a, int b)
(
int sum_a = 0;
int sum_b = 0;
while (a > 0)
(
sum_a += (a % 10);
a /= 10;
)
while (b > 0)
(
sum_b += (b % 10);
b /= 10;
)
return (sum_a.CompareTo(sum_b));
)
)
public class Program
(
public static void Main()
(
LengthComparer lc = new LengthComparer();
DigitSumComparer dsc = new DigitSumComparer();
String() strArray = ("I", "Am", "Learning", "Array", "Sorting", "In", "C#");
List strList = new List(strArray);
int() intArray = (23, 76, 12, 43, 90, 30);
List intList = new List(intArray);
strList.Sort(lc);
intList.Sort(dsc);
Console.WriteLine("Sorted String List by Length:\n");
DisplayList(strList);
Console.WriteLine("\n\n\nSorted Integer List by Sum of Digits:\n");
DisplayList(intList);
)
static void DisplayList(List myList)
(
foreach (string a in myList)
(
Console.Write(a + "\t");
)
)
static void DisplayList(List myList)
(
foreach (int a in myList)
(
Console.Write(a + "\t");
)
)
)
Salida:
Ordenar tipos de listas complejas
Los tipos de listas complejas son listas definidas por el usuario. Para ser más precisos, son listas de objetos de clases definidas por el usuario. Al estar definidos por el usuario, los objetos son una mezcla de varios tipos primitivos. Es difícil ordenar un tipo de lista compleja. El compilador de C # espera que cada clase compleja herede de la interfaz IComparable y defina el método CompareTo (). Este método contiene las instrucciones sobre cómo comparar los elementos de la lista para ordenarlos.
En el ejemplo a continuación, definimos una clase de Empleados definida por el usuario y clasificamos los objetos Empleado en función de sus ID.
Ejemplo 1
Código:
using System;
using System.Collections.Generic;
public class Employee : IComparable
(
public int id (get;set;)
public string name(get;set;)
public double salary(get;set;)
public int CompareTo(Employee e)
(
return this.id.CompareTo(e.id);
)
)
public class Program
(
public static void Main()
(
List emps = new List();
emps.Add(new Employee()
(id = 123, name = "Tom Phelps", salary = 20000.00));
emps.Add(new Employee()
(id = 897, name = "Jack Anderson", salary = 40050.50));
emps.Add(new Employee()
(id = 342, name = "Anna Spectre", salary = 31030.89));
emps.Add(new Employee()
(id = 219, name = "Veronica Clarke", salary = 66333.66));
emps.Add(new Employee()
(id = 642, name = "Jessica Williams", salary = 50505.05));
emps.Add(new Employee()
(id = 923, name = "Mike Fonseca", salary = 76543.21));
Console.WriteLine("Original Employee List:\n");
DisplayList(emps);
emps.Sort();
Console.WriteLine("\n\nSorted Employee List by IDs:\n");
DisplayList(emps);
)
static void DisplayList(List emp)
(
foreach (Employee e in emp)
(
Console.WriteLine("Id: " + e.id + ", Name: " + e.name + ", Salary: " + e.salary);
)
)
)
Salida:
Ahora, la pregunta obvia que se me viene a la mente es: ¿qué sucede si queremos clasificar los objetos de la clase Employee en función de alguna otra propiedad? Esto es posible. Necesitaríamos implementar la interfaz IComparer. Echemos un vistazo al siguiente ejemplo para comprender.
Ejemplo # 2
Código:
using System;
using System.Collections.Generic;
public class Employee
(
public int id (get;set;)
public string name(get;set;)
public double salary(get;set;)
)
public class SortByName : IComparer
(
public int Compare(Employee e1, Employee e2)
(
return e1.name.CompareTo(e2.name);
)
)
public class SortBySalary : IComparer
(
public int Compare(Employee e1, Employee e2)
(
return e1.salary.CompareTo(e2.salary);
)
)
public class Program
(
public static void Main()
(
SortByName sbn = new SortByName();
SortBySalary sbs = new SortBySalary();
List emps = new List();
emps.Add(new Employee()
(id = 123, name = "Tom Phelps", salary = 20000.00));
emps.Add(new Employee()
(id = 897, name = "Jack Anderson", salary = 40050.50));
emps.Add(new Employee()
(id = 342, name = "Anna Spectre", salary = 31030.89));
emps.Add(new Employee()
(id = 219, name = "Veronica Clarke", salary = 66333.66));
emps.Add(new Employee()
(id = 642, name = "Jessica Williams", salary = 50505.05));
emps.Add(new Employee()
(id = 923, name = "Mike Fonseca", salary = 76543.21));
emps.Sort(sbn);
Console.WriteLine("Sorted Employee List by Names:\n");
DisplayList(emps);
emps.Sort(sbs);
Console.WriteLine("\n\nSorted Employee List by Salaries:\n");
DisplayList(emps);
)
static void DisplayList(List emp)
(
foreach (Employee e in emp)
(
Console.WriteLine("Id: " + e.id + ", Name: " + e.name + ", Salary: " + e.salary);
)
)
)
Salida:
Conclusión
Entonces, este artículo cubrió en profundidad cómo clasificar colecciones en C #. Nos centramos principalmente en matrices y listas, ya que estas dos cubren todos los tipos primitivos también. Una vez que se comprende muy bien el concepto de Clasificación en C #, resulta más fácil implementar la clasificación en otras colecciones como Enumeraciones, Diccionarios, etc. Después de completar este artículo, se recomienda explorar la documentación de MSDN para obtener más implementaciones de Clasificación en C #.
Artículos recomendados
Esta es una guía para ordenar en C #. Aquí discutimos el rendimiento de la clasificación, los tipos de clasificación, como la matriz y la lista, junto con los ejemplos y la implementación del código. También puede consultar los siguientes artículos para obtener más información:
- Objetos en C #
- Modificadores de acceso en C #
- Ordenar burbujas en Java
- Punteros en C #
- Ordenar en Python
- Matriz de cadenas en JavaScript
- Comparable en Java Ejemplo | Interfaz de colección en Java
- Matriz de cadenas en C con funciones
- Diferentes ejemplos de colecciones en C #