Ejercicios de Pilas en Java, C++ y Python resueltos

Te presento los siguientes 5 ejercicios de pilas donde. Para cada uno encontrarás la solución en distintos lenguajes de programación como Java, C++ y Python. ¡Te animo a que los intentes resolver todos!

Problema: invertir una cadena

En este ejercicio debes diseñar un método «invertir» que reciba una cadena de caracteres como parámetro. Esta función deberá mostrar la cadena del revés. Debes resolver el problema usando pilas.

Ejemplo:

  • Entrada –> abcd
  • Salida –> dcba

Solución en Java – Ejercicios de pilas

static void invertir(String s) {
    var pila = new Stack<Character>();

    // Insertamos las letras en la pila
    for (int i = 0; i < s.length(); i++) {
        pila.push(s.charAt(i));
    }

    // Al desapilarlos, iremos mostrando la cadena del reves
    while (!pila.empty()) {
        System.out.print(pila.pop());
    }
}

Solución en C++

void invertir(string s) {
    stack<char> pila;

    // Insertamos las letras en la pila
    for (int i = 0; i < s.length(); i++) {
        pila.push(s[i]);
    }

    // Al desapilarlos, iremos mostrando la cadena al revés
    while (!pila.empty()) {
        cout << pila.top();
        pila.pop();
    }
}

Solución en Python

def invertir(s):
    # Simulamos una pila a partir de una lista
    pila = list(s)

    # Al desapilar las letras, iremos mostrando la cadena al revés
    while len(pila) != 0:
        print(pila.pop(), end = '')

Ejercicio: convertir decimal a binario

En este ejercicio debes diseñar un método «binario» que reciba un entero como parámetro. La función, usando una pila, deberá mostrar el número en código binario.

Solución en Java – Ejercicios de pilas

static void binario(int num) {
    var pila = new Stack<Integer>();

    while (num / 2 > 0) {
        // Apilamos los residuos
        pila.push(num % 2);
        num /= 2;
    }
    // Apilamos el ultimo cuociente
    pila.push(num);

    // Mostramos el resultado
    while (!pila.empty()) {
        System.out.print(pila.pop());
    }
}

Solución en C++

void binario(int num) {
    stack<int> pila;

    while (num / 2 > 0) {
        // Apilamos los residuos
        pila.push(num % 2);
        num /= 2;
    }
    // Apilamos el último cociente
    pila.push(num);

    // Mostramos el resultado
    while (!pila.empty()) {
        cout << pila.top();
        pila.pop();
    }
}

Solución en Python

def binario(num):
    pila = []

    while num // 2 > 0:
        # Apilamos los residuos
        pila.append(num % 2)
        num //= 2

    # Apilamos el último cociente
    pila.append(num)

    # Mostramos el resultado
    while pila:
        print(pila.pop(), end='')

Problema: separar pares e impares de una pila

Implementa un método que reciba una pila de enteros como único parámetro. Este método llamado «separarParImpar» deberá retornar la pila con los número pares en la parte inferior y los impares en la superior.

Ejemplo:

  • Entrada –> [ 2 , 3 , 6 , 8 , 11 , 13 , 18 , 21 ]
  • Salida –> [ 2 , 6 , 8 , 18 , 3 , 11 , 13 , 21 ] PARES / IMPARES

*No hace falta que los números estén ordenados de menor a mayor, esto solo es un ejemplo. Lo importante es separar los pares de los impares.*

Solución en Java – Ejercicios de pilas

static Stack<Integer> separarParImpar(Stack<Integer> pila) {
    // creamos una pila para los pares
    var pilaPares = new Stack<Integer>();
    // creamos una pila para los impares
    var pilaImpares = new Stack<Integer>();

    // introducimos cada numero a su pila correspondiente
    while (!pila.empty()) {
        if (pila.peek() % 2 == 0) {
            pilaPares.push(pila.pop());
        } else {
            pilaImpares.push(pila.pop());
        }
    }

    // apilamos los pares
    while (!pilaPares.empty()) {
        pila.push(pilaPares.pop());
    }

    // apilamos los impares
    while (!pilaImpares.empty()) {
        pila.push(pilaImpares.pop());
    }

    return pila;
}

Solución en C++

stack<int> separarParImpar(stack<int>& pila) {
    stack<int> pilaPares;
    stack<int> pilaImpares;

    // Introducimos cada número a su pila correspondiente
    while (!pila.empty()) {
        if (pila.top() % 2 == 0) {
            pilaPares.push(pila.top());
            pila.pop();
        } else {
            pilaImpares.push(pila.top());
            pila.pop();
        }
    }

    // Apilamos los pares
    while (!pilaPares.empty()) {
        pila.push(pilaPares.top());
        pilaPares.pop();
    }

    // Apilamos los impares
    while (!pilaImpares.empty()) {
        pila.push(pilaImpares.top());
        pilaImpares.pop();
    }

    return pila;
}

Solución en Python

def separar_par_impar(pila):
    pila_pares = []
    pila_impares = []

    # Introducimos cada número a su pila correspondiente
    while pila:
        num = pila.pop()
        if num % 2 == 0:
            pila_pares.append(num)
        else:
            pila_impares.append(num)

    # Apilamos los pares
    while pila_pares:
        pila.append(pila_pares.pop())

    # Apilamos los impares
    while pila_impares:
        pila.append(pila_impares.pop())

    return pila

Ejercicio: ordenar una pila

Implementa un método llamado «sort» que reciba una pila de enteros como parámetro y devuelva la pila ordenada de mayor (fondo de la pila) a menor (top de la pila).

Ejemplo:

  • Entrada –> [ 1 , 3 , 2 , 4 ]
  • Salida –> [ 4 , 3 , 2 , 1 ]

Solución en Java – Ejercicios de pilas

static Stack<Integer> sort(Stack<Integer> pila) {
    // creamos una pila auxiliar para ordenar los elementos
    var pilaOrdenada = new Stack<Integer>();
    while (!pila.empty()) {
        // sacamos el elemento de la pila
        int eliminado = pila.pop();
        while (!pilaOrdenada.empty() && eliminado > pilaOrdenada.peek()) {
            // sacamos los elementos de la pila ordenada menores que el elemento a inserir
            int eliminadoOrdenada = pilaOrdenada.pop();
            pila.push(eliminadoOrdenada);
        }
        // añadimos el elemento
        pilaOrdenada.push(eliminado);
    }
    return pilaOrdenada;
}

Solución en C++

stack<int> sort(stack<int> pila) {
    // creamos una pila auxiliar para ordenar los elementos
    stack<int> pilaOrdenada;
    while (!pila.empty()) {
        // sacamos el elemento de la pila
        int eliminado = pila.top();
        pila.pop();
        while (!pilaOrdenada.empty() && eliminado > pilaOrdenada.top()) {
            // sacamos los elementos de la pila ordenada menores que el elemento a insertar
            int eliminadoOrdenada = pilaOrdenada.top();
            pilaOrdenada.pop();
            pila.push(eliminadoOrdenada);
        }
        // añadimos el elemento
        pilaOrdenada.push(eliminado);
    }
    return pilaOrdenada;
}

Solución en Python

def sort_pila(pila):
    # Creamos una pila auxiliar para ordenar los elementos
    pila_ordenada = []
    
    while pila:
        # Sacamos el elemento de la pila
        eliminado = pila.pop()
        
        while pila_ordenada and eliminado > pila_ordenada[-1]:
            # Sacamos los elementos de la pila ordenada menores que el elemento a insertar
            eliminado_ordenada = pila_ordenada.pop()
            pila.append(eliminado_ordenada)
            
        # Añadimos el elemento
        pila_ordenada.append(eliminado)
    
    return pila_ordenada

Ejercicios de pilas: verificador de llaves

¿No te ha pasado que mientras programas abres una llave ‘ { ‘ y te olvidas de cerrarla? Este pequeño error provoca que tu programa no compile y, en consecuencia, no puedas ejecutarlo. En este ejercicio debes implementar, usando pilas, un método «esValida» que recibe como entrada una secuencia de llaves y devuelve verdadero si es válida. En caso contrario, devuelve falso.

Ejemplo:

  • Secuencia inválida: {{}{}{} –> existe alguna llave que no ha sido cerrada
  • Secuencia válida: {{}{{}{}}} –> todas la llaves han sido cerradas

Solución en Java – Ejercicios de pilas

static boolean esValida(String secuencia) {
    var pila = new Stack<Character>();
    for (int i = 0; i < secuencia.length(); i++) {
        if (secuencia.charAt(i) == '{') {
            // si abrimos llave la introducimos en la pila
            pila.push(secuencia.charAt(i));
        }
        if (secuencia.charAt(i) == '}') {
            try {
                // si cerramos llave eliminamos una llave de la pila
                pila.pop();
            } catch (Exception e) {
                return false;
            }
        }
    }
    // si la pila esta vacia se han cerrado todas las llaves
    return pila.empty();
}

Solución en C++

bool esValida(const string& secuencia) {
    stack<char> pila;
    for (int i = 0; i < secuencia.length(); i++) {
        if (secuencia[i] == '{') {
            // si abrimos llave, la introducimos en la pila
            pila.push(secuencia[i]);
        }
        if (secuencia[i] == '}') {
            if (!pila.empty()) {
                // si cerramos llave, eliminamos una llave de la pila
                pila.pop();
            } else {
                // la pila está vacía, no hay llave para cerrar
                return false;
            }
        }
    }
    // si la pila está vacía se han cerrado todas las llaves
    return pila.empty();
}

Solución en Python

def es_valida(secuencia):
    pila = []
    for char in secuencia:
        if char == '{':
            # si abrimos llave, la introducimos en la pila
            pila.append(char)
        if char == '}':
            if pila:
                # si cerramos llave, eliminamos una llave de la pila
                pila.pop()
            else:
                # la pila está vacía, no hay llave para cerrar
                return False
    # si la pila está vacía se han cerrado todas las llaves
    return len(pila) == 0

SI TIENES ALGUNA DUDA SOBRE ALGUNO DE ESTOS EJERCICIOS DE PILAS, COMPARTÉLA EN LOS COMENTARIOS PARA PODER AYUDARTE.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Estoy de acuerdo con que el responsable de la web Aprendiz de Programación use los datos proporcionados en este comentario para poder comunicarse de forma efectiva.

Scroll al inicio