Pilas y colas C

Vista previa del material en texto

Pilas y colas C++
Las pilas y colas son estructuras de datos fundamentales en la programación,
especialmente en el lenguaje C++. Ambas se utilizan para almacenar y organizar
elementos, pero difieren en la forma en que se accede a ellos.
Comencemos por las pilas. Una pila es una estructura de datos en la que los elementos se
agregan y eliminan siguiendo el principio de "último en entrar, primero en salir" (LIFO,
por sus siglas en inglés). Esto significa que el último elemento agregado a la pila es el
primero en ser eliminado. Imagina una pila de platos: cuando agregas un plato nuevo, se
coloca en la parte superior de la pila, y cuando retiras un plato, siempre tomas el que está
en la parte superior.
En C++, puedes implementar una pila utilizando la clase std::stack. Esta clase
proporciona métodos como push() para agregar elementos a la pila, pop() para eliminar el
elemento superior y top() para acceder al elemento superior sin eliminarlo. Aquí tienes un
ejemplo de cómo usar una pila en C++:
#include <iostream>
#include <stack>
int main() {
 std::stack<int> pila;
 pila.push(10);
 pila.push(20);
 pila.push(30);
 std::cout << "Elemento superior de la pila: " << pila.top() << std::endl;
 pila.pop();
 std::cout << "Elemento superior de la pila después de eliminar: " << pila.top() <<
std::endl;
 return 0;
}
En este ejemplo, creamos una pila de enteros utilizando std::stack<int>. Luego,
agregamos tres elementos a la pila utilizando push(). Después de eso, imprimimos el
elemento superior de la pila utilizando top(). Luego, eliminamos el elemento superior
utilizando pop() y volvemos a imprimir el nuevo elemento superior.
Ahora hablemos de las colas. Una cola es una estructura de datos en la que los elementos
se agregan al final y se eliminan del principio (FIFO, por sus siglas en inglés). Imagina
una cola de personas esperando en una fila: la primera persona en llegar es la primera en
ser atendida.
En C++, puedes implementar una cola utilizando la clase std::queue. Esta clase
proporciona métodos como push() para agregar elementos a la cola, pop() para eliminar
el elemento del frente y front() para acceder al elemento del frente sin eliminarlo. Aquí
tienes un ejemplo de cómo usar una cola en C++:
#include <iostream>
#include <queue>
int main() {
 std::queue<int> cola;
 cola.push(10);
 cola.push(20);
 cola.push(30);
 std::cout << "Elemento del frente de la cola: " << cola.front() << std::endl;
 cola.pop();
 std::cout << "Elemento del frente de la cola después de eliminar: " << cola.front() <<
std::endl;
 return 0;
}
En este ejemplo, creamos una cola de enteros utilizando std::queue<int>. Luego,
agregamos tres elementos a la cola utilizando push(). Después de eso, imprimimos el
elemento del frente de la cola utilizando front(). Luego, eliminamos el elemento del
frente utilizando pop() y volvemos a imprimir el nuevo elemento del frente.
En resumen, las pilas y colas son estructuras de datos esenciales en la programación. Las
pilas siguen el principio LIFO, mientras que las colas siguen el principio FIFO. Ambas se
pueden implementar en C++ utilizando las clases std::stack y std::queue,
respectivamente.