stack abstract data type adt stack creates a new stack that is empty it needs no parameters and returns an empty stack pushitem adds a new item to the top of the stack it needs the item and returns nothing pop removes the top item from the stack it needs no parameters and returns the item the stack is modified peek returns the top item from the stack but does not remove it it needs no parameters the stack is not modified isempty tests to see whether the stack is empty it needs no parameters and returns a boolean value abstract class for stacks def initself self top 1 def lenself return self top 1 def strself result joinmapstr self return top result def isemptyself return self top 1 abstractmethod def iterself pass abstractmethod def pushself value pass abstractmethod def popself pass abstractmethod def peekself pass class arraystackabstractstack def initself size10 super init self array none size def iterself probe self top while true if probe 1 return yield self arrayprobe probe 1 def pushself value self top 1 if self top lenself array self expand self arrayself top value def popself if self isempty raise indexerrorstack is empty value self arrayself top self top 1 return value def peekself expands size of the array time complexity on represents a single stack node def initself value self value value self next none class linkedliststackabstractstack def initself super init self head none def iterself probe self head while true if probe is none return yield probe value probe probe next def pushself value node stacknodevalue node next self head self head node self top 1 def popself if self isempty raise indexerrorstack is empty value self head value self head self head next self top 1 return value def peekself if self isempty raise indexerrorstack is empty return self head value abstract class for stacks initialize python list with size of 10 or user given input python list type is a dynamic array so we have to restrict its dynamic nature to make it work like a static array returns the current top element of the stack expands size of the array time complexity o n double the size of the array represents a single stack node
from abc import ABCMeta, abstractmethod


class AbstractStack(metaclass=ABCMeta):
    
    def __init__(self):
        self._top = -1

    def __len__(self):
        return self._top + 1

    def __str__(self):
        result = " ".join(map(str, self))
        return 'Top-> ' + result

    def is_empty(self):
        return self._top == -1

    @abstractmethod
    def __iter__(self):
        pass

    @abstractmethod
    def push(self, value):
        pass

    @abstractmethod
    def pop(self):
        pass

    @abstractmethod
    def peek(self):
        pass


class ArrayStack(AbstractStack):
    def __init__(self, size=10):
        
        super().__init__()
        self._array = [None] * size

    def __iter__(self):
        probe = self._top
        while True:
            if probe == -1:
                return
            yield self._array[probe]
            probe -= 1

    def push(self, value):
        self._top += 1
        if self._top == len(self._array):
            self._expand()
        self._array[self._top] = value

    def pop(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        value = self._array[self._top]
        self._top -= 1
        return value

    def peek(self):
        
        if self.is_empty():
            raise IndexError("Stack is empty")
        return self._array[self._top]

    def _expand(self):
        
        self._array += [None] * len(self._array)  


class StackNode:
    
    def __init__(self, value):
        self.value = value
        self.next = None


class LinkedListStack(AbstractStack):

    def __init__(self):
        super().__init__()
        self.head = None

    def __iter__(self):
        probe = self.head
        while True:
            if probe is None:
                return
            yield probe.value
            probe = probe.next

    def push(self, value):
        node = StackNode(value)
        node.next = self.head
        self.head = node
        self._top += 1

    def pop(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        value = self.head.value
        self.head = self.head.next
        self._top -= 1
        return value

    def peek(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        return self.head.value