El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Ejercicios con Pilas

Siguiente ►
►

En esta sección, vamos a poner en práctica los conceptos aprendidos sobre pilas. Realizaremos una serie de ejercicios que te ayudarán a consolidar tus conocimientos y habilidades en el uso de esta estructura de datos.

Ejercicio 1: Implementar una Pila desde Cero

Enunciado

Implementa una pila utilizando una lista en Python. La pila debe soportar las siguientes operaciones:

  • push(element): Añadir un elemento a la pila.
  • pop(): Eliminar y devolver el elemento en la cima de la pila.
  • peek(): Devolver el elemento en la cima de la pila sin eliminarlo.
  • is_empty(): Devolver True si la pila está vacía, de lo contrario False.
  • size(): Devolver el número de elementos en la pila.

Solución

class Pila:
    def __init__(self):
        self.items = []

    def push(self, element):
        self.items.append(element)

    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        else:
            return None

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        else:
            return None

    def is_empty(self):
        return len(self.items) == 0

    def size(self):
        return len(self.items)

# Ejemplo de uso
pila = Pila()
pila.push(1)
pila.push(2)
pila.push(3)
print(pila.pop())  # Salida: 3
print(pila.peek())  # Salida: 2
print(pila.size())  # Salida: 2
print(pila.is_empty())  # Salida: False

Explicación

  • __init__: Inicializa una lista vacía para almacenar los elementos de la pila.
  • push: Añade un elemento al final de la lista.
  • pop: Elimina y devuelve el último elemento de la lista, si la pila no está vacía.
  • peek: Devuelve el último elemento de la lista sin eliminarlo, si la pila no está vacía.
  • is_empty: Comprueba si la lista está vacía.
  • size: Devuelve el número de elementos en la lista.

Ejercicio 2: Verificar una Expresión Balanceada

Enunciado

Escribe una función que verifique si los paréntesis en una expresión están balanceados. La función debe devolver True si la expresión está balanceada y False en caso contrario.

Solución

def esta_balanceada(expresion):
    pila = Pila()
    for char in expresion:
        if char in "({[":
            pila.push(char)
        elif char in ")}]":
            if pila.is_empty():
                return False
            top = pila.pop()
            if not ((top == '(' and char == ')') or 
                    (top == '{' and char == '}') or 
                    (top == '[' and char == ']')):
                return False
    return pila.is_empty()

# Ejemplo de uso
print(esta_balanceada("()"))  # Salida: True
print(esta_balanceada("({[()]})"))  # Salida: True
print(esta_balanceada("({[([)])"))  # Salida: False

Explicación

  • Recorrido de la expresión: Recorre cada carácter de la expresión.
  • Apertura de paréntesis: Si el carácter es un paréntesis de apertura ((, {, [), se añade a la pila.
  • Cierre de paréntesis: Si el carácter es un paréntesis de cierre (), }, ]), se comprueba si la pila está vacía. Si está vacía, la expresión no está balanceada. Si no está vacía, se compara el paréntesis de cierre con el paréntesis de apertura en la cima de la pila.
  • Resultado final: Al final del recorrido, la pila debe estar vacía para que la expresión esté balanceada.

Ejercicio 3: Invertir una Cadena

Enunciado

Escribe una función que invierta una cadena utilizando una pila.

Solución

def invertir_cadena(cadena):
    pila = Pila()
    for char in cadena:
        pila.push(char)
    
    cadena_invertida = ""
    while not pila.is_empty():
        cadena_invertida += pila.pop()
    
    return cadena_invertida

# Ejemplo de uso
print(invertir_cadena("Hola Mundo"))  # Salida: "odnuM aloH"

Explicación

  • Pushing: Cada carácter de la cadena se añade a la pila.
  • Popping: Se extraen los caracteres de la pila y se concatenan para formar la cadena invertida.

Ejercicio 4: Evaluar una Expresión Postfija

Enunciado

Escribe una función que evalúe una expresión postfija (notación polaca inversa).

Solución

def evaluar_postfija(expresion):
    pila = Pila()
    for char in expresion.split():
        if char.isdigit():
            pila.push(int(char))
        else:
            operando2 = pila.pop()
            operando1 = pila.pop()
            if char == '+':
                pila.push(operando1 + operando2)
            elif char == '-':
                pila.push(operando1 - operando2)
            elif char == '*':
                pila.push(operando1 * operando2)
            elif char == '/':
                pila.push(operando1 / operando2)
    return pila.pop()

# Ejemplo de uso
print(evaluar_postfija("3 4 + 2 * 7 /"))  # Salida: 2.0

Explicación

  • Recorrido de la expresión: Recorre cada token de la expresión.
  • Operando: Si el token es un número, se añade a la pila.
  • Operador: Si el token es un operador, se extraen los dos operandos de la pila, se aplica el operador y el resultado se añade de nuevo a la pila.
  • Resultado final: Al final del recorrido, el resultado de la expresión se encuentra en la cima de la pila.

Conclusión

En esta sección, hemos trabajado con varios ejercicios prácticos que te ayudarán a entender mejor cómo funcionan las pilas y cómo pueden ser utilizadas en diferentes contextos. Asegúrate de practicar estos ejercicios y experimentar con tus propias variaciones para reforzar tu comprensión.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados