Algoritmos y estructuras de datos en C#: guía completa para desarrolladores .NET

Algoritmos y estructuras de datos en C#: fundamento para código .NET eficiente

En el desarrollo moderno en la plataforma .NET, el conocimiento de algoritmos y estructuras de datos es una habilidad obligatoria para crear aplicaciones productivas y escalables. Independientemente de si escribes servicios web en ASP.NET Core, aplicaciones de escritorio en WPF o soluciones móviles en Xamarin, la elección correcta de la estructura de datos afecta directamente la velocidad de ejecución del programa y el consumo de memoria. En este artículo, analizaremos las estructuras de datos y algoritmos clave en el lenguaje C#, acompañando cada sección con ejemplos prácticos de código.

1. Estructuras de datos básicas en C#: arrays y listas

Empecemos por lo más fundamental. En C# existen varios tipos integrados para almacenar colecciones, y comprender su funcionamiento interno es críticamente importante.

Arrays (Array)

Un array es una secuencia fija de elementos del mismo tipo. Proporciona el acceso más rápido por índice (O(1)), pero no permite cambiar su tamaño después de la creación.

int[] numbers = new int[5] { 10, 20, 30, 40, 50 };// Acceso por índiceint thirdElement = numbers[2]; // 30// Cambio de elementonumbers[3] = 100;

Usa arrays cuando la cantidad de elementos se conozca de antemano y no vaya a cambiar (por ejemplo, para almacenar constantes o buffers fijos).

Lista (List<T>)

List<T> es un array dinámico. Se expande automáticamente al añadir nuevos elementos. Internamente usa un array normal que se recrea cuando se supera la capacidad.

List<string> fruits = new List<string>();fruits.Add("Manzana");fruits.Add("Plátano");fruits.Add("Naranja");Console.WriteLine(fruits.Count); // 3fruits.RemoveAt(1); // Eliminamos "Plátano"

List<T> es una elección universal para la mayoría de tareas donde se requiere acceso secuencial y cambios frecuentes en el tamaño de la colección.

2. Pila y cola: principios LIFO y FIFO

Estas dos estructuras de datos implementan reglas estrictas para añadir y extraer elementos. Son indispensables para el análisis de expresiones, el procesamiento de tareas diferidas y la implementación de algoritmos de recorrido.

Pila (Stack<T>)

La pila funciona bajo el principio "último en entrar, primero en salir" (LIFO). En .NET, la pila se implementa como una colección genérica.

Stack<int> stack = new Stack<int>();stack.Push(1);stack.Push(2);stack.Push(3);

int top = stack.Pop(); // 3int peek = stack.Peek(); // 2 (sin eliminación)

Ejemplo real: verificar la corrección de paréntesis en una cadena o implementar el botón "Atrás" en un navegador.

Cola (Queue<T>)

La cola sigue el principio "primero en entrar, primero en salir" (FIFO). Es la elección ideal para procesar tareas en el orden en que llegan.

Queue<string> queue = new Queue<string>();queue.Enqueue("Tarea 1");queue.Enqueue("Tarea 2");queue.Enqueue("Tarea 3");

string task = queue.Dequeue(); // "Tarea 1"string nextTask = queue.Peek(); // "Tarea 2"

Las colas se utilizan activamente en los patrones Producer-Consumer, en el procesamiento de mensajes y en sistemas de logging.

3. Árboles y algoritmos recursivos en C#

Los árboles son estructuras jerárquicas donde cada nodo puede tener varios nodos hijos. Un lugar especial lo ocupan los árboles binarios de búsqueda (BST), que proporcionan búsqueda, inserción y eliminación rápidas (O(log n) en promedio).

Implementación de un árbol binario de búsqueda

public class TreeNode{    public int Value;    public TreeNode Left;    public TreeNode Right;

    public TreeNode(int value)    {        Value = value;    }}

public class BinarySearchTree{    public TreeNode Root;

    public void Insert(int value)    {        Root = InsertRec(Root, value);    }

    private TreeNode InsertRec(TreeNode root, int value)    {        if (root == nu