En informática, las pilas siguen el principio LIFO (último en entrar, primero en salir), mientras que las colas siguen FIFO (primero en entrar, primero en salir). Es posible emular una cola usando dos pilas y una pila usando dos colas, aprovechando sus comportamientos intrínsecos.

Emulación de una Cola con Dos Pilas

Se utilizan dos pilas: una para inserciones y otra para extracciones. La pila de entrada almacena los elementos nuevos, y la pila de salida se emplea para devolver elemenots en orden de llegada.

Estructura del Componente

#include <stack>
using namespace std;

struct ColaConPilas {
    stack<int> pilaEntrada;   // Almacena elementos entrantes
    stack<int> pilaSalida;    // Gestiona extracciones
};

Operación de Inserción (Encolar)

Los elementos se insertan directamente en la pila de entrada.

void encolar(ColaConPilas* cola, int valor) {
    cola->pilaEntrada.push(valor);
}

Operación de Extracción (Desencolar)

Si la pila de salida está vacía, se transfieren todos los elementos de la pila de entrada a la pila de salida, invirtiendo su orden. Luego, se extrae el tope de la pila de salida.

int desencolar(ColaConPilas* cola) {
    if (cola->pilaSalida.empty()) {
        while (!cola->pilaEntrada.empty()) {
            cola->pilaSalida.push(cola->pilaEntrada.top());
            cola->pilaEntrada.pop();
        }
    }
    int resultado = cola->pilaSalida.top();
    cola->pilaSalida.pop();
    return resultado;
}

Emulación de una Pila con Dos Colas

Se emplean dos colas: una principle y otra auxiliar. La cola principal retiene los elementos, y la cola auxiliar facilita el acceso al último elemento insertado.

Estructura del Componente

#include <queue>
using namespace std;

struct PilaConColas {
    queue<int> colaPrincipal;  // Almacena elementos
    queue<int> colaAuxiliar;   // Apoya operaciones
};

Operación de Inserción (Apilar)

Los elementos se insertan siempre en la cola principal.

void apilar(PilaConColas* pila, int valor) {
    pila->colaPrincipal.push(valor);
}

Operación de Extracción (Desapilar)

Para extraer el último elemento insertado, se mueven todos los elementos excepto el último de la cola principal a la colla auxiliar. Luego, se elimina el único elemento restante en la cola principal. Los roles de las colas se intercambian si la cola principal está vacía.

int desapilar(PilaConColas* pila) {
    if (pila->colaPrincipal.empty()) {
        swap(pila->colaPrincipal, pila->colaAuxiliar);
    }
    while (pila->colaPrincipal.size() > 1) {
        pila->colaAuxiliar.push(pila->colaPrincipal.front());
        pila->colaPrincipal.pop();
    }
    int valor = pila->colaPrincipal.front();
    pila->colaPrincipal.pop();
    return valor;
}