Estructuras de Datos en C# 15: Desafíos Finales y Proyecto Integrador

Introducción a la clase

En esta última clase aplicaremos todos los conocimientos adquiridos sobre estructuras de datos y algoritmos en C# mediante una serie de desafíos finales y un proyecto integrador. Estos ejercicios te ayudarán a consolidar tu aprendizaje en optimización, estructuras de datos avanzadas y arquitectura de software.

¿Qué obtendrás de esta clase?

• Resolverás desafíos prácticos que combinan diferentes estructuras de datos y algoritmos.
• Implementarás un proyecto final aplicando Clean Architecture, Vertical Slice o Arquitectura Hexagonal.
• Aprenderás a evaluar el rendimiento de los algoritmos y mejorar la eficiencia.
• Crearás un sistema completo que integra estructuras de datos con C# en un entorno real.

Parte 1: Desafíos Finales

A continuación, encontrarás una serie de desafíos que te ayudarán a aplicar todo lo aprendido.

Desafío 1: Implementar un sistema de gestión de tareas con una Cola de Prioridad

Requisitos:

• Implementar una cola de prioridad donde las tareas con mayor prioridad se atienden primero.
• Las tareas deben almacenarse en un diccionario con su nivel de prioridad.
• Simular el procesamiento de tareas en orden de prioridad.

Pista: Utiliza SortedDictionary<int, Queue<string>> para manejar tareas con prioridad.

using System;
using System.Collections.Generic;

class GestionTareas
{
    static void Main()
    {
        SortedDictionary<int, Queue<string>> tareas = new SortedDictionary<int, Queue<string>>();

        AgregarTarea(tareas, "Revisar correo", 2);
        AgregarTarea(tareas, "Atender reunión", 1);
        AgregarTarea(tareas, "Enviar reporte", 3);

        while (tareas.Count > 0)
        {
            var prioridad = tareas.Keys.Min();
            var tarea = tareas[prioridad].Dequeue();
            Console.WriteLine($"Procesando tarea: {tarea} (Prioridad {prioridad})");

            if (tareas[prioridad].Count == 0)
                tareas.Remove(prioridad);
        }
    }

    static void AgregarTarea(SortedDictionary<int, Queue<string>> tareas, string descripcion, int prioridad)
    {
        if (!tareas.ContainsKey(prioridad))
            tareas[prioridad] = new Queue<string>();

        tareas[prioridad].Enqueue(descripcion);
    }
}

Este código procesa tareas según su prioridad de menor a mayor.

Desafío 2: Implementar un sistema de rutas usando Grafos y BFS

Requisitos:

• Representar un mapa de ciudades como un grafo no dirigido.
• Permitir que el usuario busque la ruta más corta entre dos ciudades.
• Implementar BFS para encontrar el camino más corto.

Pista: Usa un diccionario con listas de adyacencia para representar el grafo.

using System;
using System.Collections.Generic;

class MapaCiudades
{
    static Dictionary<string, List<string>> grafo = new Dictionary<string, List<string>>();

    static void Main()
    {
        AgregarConexion("A", "B");
        AgregarConexion("A", "C");
        AgregarConexion("B", "D");
        AgregarConexion("C", "D");
        AgregarConexion("D", "E");

        Console.WriteLine("Ingrese ciudad de origen:");
        string origen = Console.ReadLine();
        Console.WriteLine("Ingrese ciudad de destino:");
        string destino = Console.ReadLine();

        var ruta = BuscarRuta(origen, destino);
        Console.WriteLine(ruta != null ? $"Ruta encontrada: {string.Join(" -> ", ruta)}" : "No hay ruta disponible.");
    }

    static void AgregarConexion(string ciudad1, string ciudad2)
    {
        if (!grafo.ContainsKey(ciudad1)) grafo[ciudad1] = new List<string>();
        if (!grafo.ContainsKey(ciudad2)) grafo[ciudad2] = new List<string>();

        grafo[ciudad1].Add(ciudad2);
        grafo[ciudad2].Add(ciudad1);
    }

    static List<string> BuscarRuta(string inicio, string destino)
    {
        if (!grafo.ContainsKey(inicio) || !grafo.ContainsKey(destino)) return null;

        Queue<List<string>> cola = new Queue<List<string>>();
        HashSet<string> visitados = new HashSet<string>();

        cola.Enqueue(new List<string> { inicio });
        visitados.Add(inicio);

        while (cola.Count > 0)
        {
            var ruta = cola.Dequeue();
            string ciudadActual = ruta[^1];

            if (ciudadActual == destino)
                return ruta;

            foreach (var vecino in grafo[ciudadActual])
            {
                if (!visitados.Contains(vecino))
                {
                    var nuevaRuta = new List<string>(ruta) { vecino };
                    cola.Enqueue(nuevaRuta);
                    visitados.Add(vecino);
                }
            }
        }

        return null;
    }
}

Este código encuentra la ruta más corta entre dos ciudades usando BFS.

Parte 2: Proyecto Integrador

Descripción del Proyecto:
Diseña un sistema de reservas de vuelos que permita:

1. Administrar vuelos disponibles (usando una lista o diccionario).
2. Permitir a los usuarios reservar boletos (almacenando reservas en una cola).
3. Optimizar la búsqueda de vuelos usando búsqueda binaria si los vuelos están ordenados.
4. Calcular la mejor ruta entre aeropuertos usando un grafo y BFS.

Requisitos:
✔ Implementar una estructura de datos eficiente para manejar vuelos.
✔ Utilizar algoritmos de búsqueda para encontrar vuelos rápidamente.
✔ Procesar reservas en orden usando una cola FIFO.
✔ Calcular la mejor ruta entre aeropuertos con BFS.

Resumen de la clase

• Aplicamos estructuras de datos avanzadas en problemas reales.
• Implementamos colas de prioridad, grafos, búsqueda BFS y listas ordenadas.
• Creamos un proyecto final aplicando todas las estructuras de datos vistas en el curso.

Conclusión del Curso

Has completado el curso de Estructuras de Datos y Algoritmos en C#. Ahora tienes una base sólida para optimizar código, seleccionar estructuras de datos adecuadas y aplicar patrones de arquitectura moderna.

¿Qué sigue?

• Profundizar en algoritmos avanzados como Dijkstra, A*, Programación Dinámica.
• Aprender sobre concurrencia y optimización en aplicaciones de alto rendimiento.
• Aplicar estas técnicas en proyectos reales o participar en desafíos de código.

Agradecimiento

Muchas gracias por seguir este curso hasta el final. Espero que el conocimiento adquirido aquí te ayude a crear software más eficiente, escalable y bien estructurado.