Programa de Python para invertir una pila

La pila es una estructura de datos lineal que funciona con el concepto LIFO. LIFO significa último en entrar, primero en salir. En la pila, la inserción y la eliminación son posibles en un extremo, el extremo se llama la parte superior de la pila.

En este artículo, veremos cómo revertir una pila usando Python.
 

Algoritmo: 

• Defina alguna función básica de la pila como empujar(), pop(), mostrar(), vacío(), para operaciones básicas como agregar un elemento en la pila, eliminar un elemento en la pila, mostrar la pila, verificar que la pila dada sea vacío o no.
• Defina dos funciones recursivas BottomInsertion() y Reverse()..

BottomInsertion() : este método agrega un elemento en la parte inferior de la pila y BottomInsertion acepta dos valores como argumento, primero es la pila y el segundo es elementos, este es un método recursivo.

# insert element at the bottom of the stack
def BottomInsert(s, value):
    # if stack is empty then call push() method.
    if s.empty():  
        s.push(value)
        
    # if stack is not empty then execute else
    # block
    else:
    
        # remove the element and store it to
        # popped  
        popped = s.pop()
        
        # invoke it self and pass stack and value 
        # as an argument.
        BottomInsert(s, value)
        
        # append popped item in the bottom of the stack 
        s.push(popped)

Reverse() : el método es elementos inversos de la pila, este método acepta la pila como un argumento Reverse() también es una función Recursiva(). Reverse() es el método BottomInsertion() invocado para completar la operación inversa en la pila.

# Reverse()
def Reverse(s): 

    # check the stack is empty of not  
    if s.empty():
    
        # if empty then do nothing
        pass
        
    # if stack is not empty then 
    else:
    
        # pop element and stare it to popped
        popped = s.pop()
        
        # call it self ans pass stack as an argument
        Reverse(s)
        
        # call BottomInsert() method and pass stack
        # and popped element as an argument
        BottomInsert(s, popped)

A continuación se muestra la implementación.

# create class for stack
class Stack:
  
    # create empty list
    def __init__(self):
        self.Elements = []
          
    # push() for insert an element
    def push(self, value):
        self.Elements.append(value)
        
    # pop() for remove an element
    def pop(self):
        return self.Elements.pop()
      
    # empty() check the stack is empty of not
    def empty(self):
        return self.Elements == []
      
    # show() display stack
    def show(self):
        for value in reversed(self.Elements):
            print(value)
  
# Insert_Bottom() insert value at bottom
def BottomInsert(s, value):
    
    # check the stack is empty or not
    if s.empty(): 
          
        # if stack is empty then call
        # push() method.
        s.push(value)
          
    # if stack is not empty then execute
    # else block
    else:
        popped = s.pop()
        BottomInsert(s, value)
        s.push(popped)
  
# Reverse() reverse the stack
def Reverse(s):
    if s.empty():
        pass
    else:
        popped = s.pop()
        Reverse(s)
        BottomInsert(s, popped)
  
  
# create object of stack class
stk = Stack()
  
stk.push(1)
stk.push(2)
stk.push(3)
stk.push(4)
stk.push(5)
  
print("Original Stack")
stk.show()
  
print("\nStack after Reversing")
Reverse(stk)
stk.show()

Producción:

Original Stack
5
4
3
2
1

Stack after Reversing
1
2
3
4
5