cadenas en JavaScript pero orientado al concepto de pilas

agosto 10, 2025

¡Excelente! Si quieres trabajar con cadenas en JavaScript pero orientado al concepto de pilas (LIFO: Last-In, First-Out), aquí tienes 10 ejercicios que aprovechan operaciones de pilas (push, pop, peek, etc.) para manipular strings:

1. Invertir una cadena usando una pila

Implementa una función que invierta una cadena simulando una pila.

function invertirConPila(cadena) {
    const pila = [];
    for (let char of cadena) pila.push(char); // Apilar
    let invertida = '';
    while (pila.length > 0) invertida += pila.pop(); // Desapilar
    return invertida;
}
console.log(invertirConPila("hola")); // "aloh"

2. Verificar paréntesis balanceados

Usa una pila para verificar si los paréntesis en una cadena están balanceados.

function parentesisBalanceados(cadena) {
    const pila = [];
    for (let char of cadena) {
        if (char === '(') pila.push(char);
        else if (char === ')') {
            if (pila.length === 0) return false;
            pila.pop();
        }
    }
    return pila.length === 0;
}
console.log(parentesisBalanceados("(()())")); // true

3. Eliminar caracteres duplicados adyacentes

Usa una pila para eliminar duplicados consecutivos (ej: "aabccba" → "abcba").

function eliminarDuplicadosAdyacentes(cadena) {
    const pila = [];
    for (let char of cadena) {
        if (pila.length > 0 && pila[pila.length - 1] === char) pila.pop();
        else pila.push(char);
    }
    return pila.join('');
}
console.log(eliminarDuplicadosAdyacentes("aabccbaa")); // "abcba"

4. Simplificar rutas de archivos (como en Unix)

Resuelve rutas como /.././abc//./def/ → /abc/def usando una pila.

function simplificarRuta(ruta) {
    const partes = ruta.split('/');
    const pila = [];
    for (let parte of partes) {
        if (parte === '..') pila.pop();
        else if (parte !== '' && parte !== '.') pila.push(parte);
    }
    return '/' + pila.join('/');
}
console.log(simplificarRuta("/.././abc//./def/")); // "/abc/def"

5. Evaluar expresiones postfijas (notación polaca inversa)

Evalúa expresiones como "23+5*" (que es (2+3)*5 = 25) usando una pila.

function evaluarPostfija(expresion) {
    const pila = [];
    for (let token of expresion) {
        if (!isNaN(token)) pila.push(parseInt(token));
        else {
            const b = pila.pop(), a = pila.pop();
            if (token === '+') pila.push(a + b);
            else if (token === '-') pila.push(a - b);
            else if (token === '*') pila.push(a * b);
            else if (token === '/') pila.push(a / b);
        }
    }
    return pila.pop();
}
console.log(evaluarPostfija("23+5*")); // 25

6. Validar etiquetas HTML anidadas

Verifica si las etiquetas de apertura y cierre están correctamente anidadas (ej: <div><p></p></div> → válido).

function etiquetasHTMLValidas(html) {
    const pila = [];
    const regex = /<\/?([a-z]+)>/g;
    let match;
    while ((match = regex.exec(html)) !== null) {
        const etiqueta = match[1];
        if (match[0][1] !== '/') pila.push(etiqueta); // Apertura
        else {
            if (pila.length === 0 || pila.pop() !== etiqueta) return false;
        }
    }
    return pila.length === 0;
}
console.log(etiquetasHTMLValidas("<div><p></p></div>")); // true

7. Decodificar cadena con patrones repetidos

Decodifica cadenas como "3[a]2[bc]" → "aaabcbc" usando una pila para manejar anidación.

function decodificarCadena(cadena) {
    const pila = [];
    let num = 0, str = '';
    for (let char of cadena) {
        if (!isNaN(char)) num = num * 10 + parseInt(char);
        else if (char === '[') {
            pila.push({ str, num });
            str = '';
            num = 0;
        } else if (char === ']') {
            const { str: prevStr, num: prevNum } = pila.pop();
            str = prevStr + str.repeat(prevNum);
        } else str += char;
    }
    return str;
}
console.log(decodificarCadena("3[a]2[bc]")); // "aaabcbc"

8. Remover asteriscos y sus caracteres anteriores

Dada una cadena como "ab*c*d", elimina cada * y el carácter anterior (resultado: "d").

function removerAsteriscos(cadena) {
    const pila = [];
    for (let char of cadena) {
        if (char === '*') pila.pop();
        else pila.push(char);
    }
    return pila.join('');
}
console.log(removerAsteriscos("ab*c*d")); // "d"

9. Construir una cadena con deletions mínimos

Dadas dos cadenas s y t, determina si s puede convertirse en t usando una pila para simular deletions.

function esSubsecuencia(s, t) {
    const pila = s.split('');
    for (let i = t.length - 1; i >= 0 && pila.length > 0; i--) {
        if (t[i] === pila[pila.length - 1]) pila.pop();
    }
    return pila.length === 0;
}
console.log(esSubsecuencia("abc", "ahbgdc")); // true

10. Simular el editor de texto "Undo" (Ctrl+Z)

Usa dos pilas: una para el texto actual y otra para los cambios deshechos.

class EditorTexto {
    constructor() {
        this.pila = [];
        this.undoStack = [];
    }
    escribir(char) {
        this.pila.push(char);
    }
    deshacer() {
        if (this.pila.length > 0) this.undoStack.push(this.pila.pop());
    }
    rehacer() {
        if (this.undoStack.length > 0) this.pila.push(this.undoStack.pop());
    }
    getTexto() {
        return this.pila.join('');
    }
}

const editor = new EditorTexto();
editor.escribir('a');
editor.escribir('b');
editor.deshacer();
console.log(editor.getTexto()); // "a"

Conceptos clave aplicados:

Pila como estructura LIFO: En todos los ejercicios, la pila ayuda a manejar el orden inverso o anidado.
Uso de push y pop: Operaciones básicas para simular la pila.
Aplicaciones clásicas: Balanceo de símbolos, inversión, procesamiento de strings.

¿Quieres que profundicemos en algún ejercicio en particular? 🚀

Buscar este blog

SOTELO-javascript