Los problemas 232 y 225 comparten una estrategia fundamental para implementar estructuras de datos mediente otras, lo que permite abordarlos de manera eficiente.

class ColaConPilas {
public:
    void push(int valor) {
        pila_entrada.push(valor);
    }
    
    int pop() {
        while (!pila_entrada.empty()) {
            pila_salida.push(pila_entrada.top());
            pila_entrada.pop();
        }
        int resultado = pila_salida.top();
        pila_salida.pop();
        while (!pila_salida.empty()) {
            pila_entrada.push(pila_salida.top());
            pila_salida.pop();
        }
        return resultado;
    }
    
    int peek() {
        while (!pila_entrada.empty()) {
            pila_salida.push(pila_entrada.top());
            pila_entrada.pop();
        }
        int resultado = pila_salida.top();
        while (!pila_salida.empty()) {
            pila_entrada.push(pila_salida.top());
            pila_salida.pop();
        }
        return resultado;
    }
    
    bool empty() {
        return pila_entrada.empty();
    }
private:
    std::stack<int> pila_entrada;
    std::stack<int> pila_salida;
};

La implementación de pilas mediante colas sigue un enfoque similar, utilizando dos colas para gestionar el comportamiento de LIFO.

class PilaConColas {
public:
    void push(int valor) {
        cola_auxiliar.push(valor);
        while (!cola_principal.empty()) {
            cola_auxiliar.push(cola_principal.front());
            cola_principal.pop();
        }
        std::swap(cola_principal, cola_auxiliar);
    }
    
    int pop() {
        int elemento = cola_principal.front();
        cola_principal.pop();
        return elemento;
    }
    
    int top() {
        return cola_principal.front();
    }
    
    bool empty() {
        return cola_principal.empty();
    }
private:
    std::queue<int> cola_principal;
    std::queue<int> cola_auxiliar;
};

El problema 20 requiere validar expresiones matemáticas mediente el uso de una pila para verificar coincidencias de símbolos.

class ValidadorExpresiones {
public:
    bool isValid(std::string expresion) {
        std::vector<char> pila;
        for (char caracter : expresion) {
            if (caracter == '(' || caracter == '[' || caracter == '{') {
                pila.push_back(caracter);
            } else {
                if (pila.empty()) return false;
                char ultimo = pila.back();
                if ((caracter == ')' && ultimo != '(') ||
                    (caracter == ']' && ultimo != '[') ||
                    (caracter == '}' && ultimo != '{')) {
                    return false;
                }
                pila.pop_back();
            }
        }
        return pila.empty();
    }
};

El problema 1047 se resuelve eficientemente usando una sola pila para eliminar caracteres adyacentes repetidos en una cadena.

class EliminadorDuplicados {
public:
    std::string removeDuplicates(std::string cadena) {
        std::stack<char> pila;
        for (char c : cadena) {
            if (!pila.empty() && pila.top() == c) {
                pila.pop();
            } else {
                pila.push(c);
            }
        }
        std::string resultado;
        while (!pila.empty()) {
            resultado += pila.top();
            pila.pop();
        }
        std::reverse(resultado.begin(), resultado.end());
        return resultado;
    }
};