Stack

• A linear data structure that follows the Last In, First Out (LIFO) or First In, Last Out (FILO) principle.
• Elements are added and removed from only one end, called the top of the stack.

Common Operations

• push: add an element
• pop: remove the top element
• peek: retrieve the top element without removing it

Advantages

• Simple Implementation: Easy to implement and use.
• Efficient Operations: Push and pop operations have O(1) time complexity.
• Memory Management: Utilised in memory management for function calls (call stack).

Disadvantages

• Limited Access: Only the top element can be accessed, limiting direct access to other elements.
• Fixed Size (Array-based Stacks): For stacks implemented using arrays, the size is fixed and can lead to overflow.

Real-Life Applications

• Function Call Management: Managing function calls and recursion in programming languages.
• Expression Evaluation: Evaluating expressions in compilers and calculators.
• Backtracking: Algorithms that use backtracking (e.g., maze solving, depth-first search).
• Undo Mechanism: Implementing undo features in text editors and applications.

Implementation

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

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

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

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

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

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

More code implementations (in all of your favourite languages - Java, C++, Swift) can be found here.

That's a wrap. Get subscribed if you aren't already. Come back tomorrow for more.

If you found this useful, share it with your friends.