Algoritmos y estructuras de datos en C++: guía práctica

Algoritmos y estructuras de datos en C++: de la teoría a la práctica

Dominar los algoritmos y las estructuras de datos es una etapa clave para convertirse en un desarrollador profesional. Sin una comprensión profunda de cómo organizar y procesar datos de manera eficiente, es imposible crear aplicaciones productivas y escalables. C++ ofrece capacidades únicas para el trabajo de bajo nivel con memoria y un alto rendimiento, lo que lo convierte en el lenguaje ideal para estudiar este tema.

En este artículo, exploraremos algoritmos y estructuras de datos fundamentales en C++ con ejemplos prácticos de código que podrá aplicar de inmediato en sus proyectos. No nos adentraremos en cálculos matemáticos abstractos; nuestro enfoque está en la implementación real y la comprensión de los principios de funcionamiento.

1. Arreglos dinámicos y gestión de memoria

Empecemos con lo básico: los arreglos dinámicos. A diferencia de los arreglos estáticos, cuyo tamaño se fija en tiempo de compilación, los arreglos dinámicos permiten cambiar su tamaño durante la ejecución del programa. En C++, se utilizan los operadores new[] y delete[] para esto.

#include <iostream>\n\nint main() {\n    int size = 5;\n    int* arr = new int[size]; // asignación de memoria\n    \n    // Inicialización\n    for(int i = 0; i < size; i++) {\n        arr[i] = i * 10;\n    }\n    \n    // Salida\n    for(int i = 0; i < size; i++) {\n        std::cout << arr[i] << " ";\n    }\n    \n    delete[] arr; // liberación de memoria\n    return 0;\n}

Es importante recordar que al trabajar con memoria dinámica, usted es responsable de liberarla. Las fugas de memoria son uno de los problemas más comunes en C++. Se recomienda usar punteros inteligentes (std::unique_ptr, std::shared_ptr) de la biblioteca estándar para la gestión automática de la memoria.

2. Pila y cola: estructuras de datos clásicas

La pila y la cola son dos estructuras de datos fundamentales que implementan los principios LIFO (Last In, First Out) y FIFO (First In, First Out) respectivamente. Veamos su implementación en C++ utilizando un arreglo dinámico.

Implementación de la pila

#include <iostream>\n#include <stdexcept>\n\nclass Stack {\nprivate:\n    int* data;\n    int capacity;\n    int top;\n    \npublic:\n    Stack(int size) : capacity(size), top(-1) {\n        data = new int[capacity];\n    }\n    \n    ~Stack() {\n        delete[] data;\n    }\n    \n    void push(int value) {\n        if(top >= capacity - 1) {\n            throw std::overflow_error("Stack overflow");\n        }\n        data[++top] = value;\n    }\n    \n    int pop() {\n        if(isEmpty()) {\n            throw std::underflow_error("Stack underflow");\n        }\n        return data[top--];\n    }\n    \n    bool isEmpty() const {\n        return top == -1;\n    }\n    \n    int peek() const {\n        if(isEmpty()) {\n            throw std::underflow_error("Stack is empty");\n        }\n        return data[top];\n    }\n};\n\nint main() {\n    Stack stack(5);\n    stack.push(10);\n    stack.push(20);\n    stack.push(30);\n    \n    std::cout << "Elemento superior: " << stack.peek() << std::endl;\n    std::cout << "Extrayendo: " << stack.pop() << std::endl;\n    std::cout << "Extrayendo: " << stack.pop() << std::endl;\n    \n    return 0;\n}

Implementación de la cola

#include <iostream>\n\nclass Queue {\nprivate:\n    int* data;\n    int capacity;\n    int front;\n    int rear;\n    int count;\n    \npublic:\n    Queue(int size) : capacity(size), front(0), rear(-1), count(0) {\n        data = new int[capacity];\n    }\n    \n    ~Queue() {\n        delete[] data;\n    }\n    \n    void enqueue(int value) {\n        if(isFull()) {\n            throw std::overflow_error("Queue overflow");\n        }\n        rear = (rear + 1) %