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.