# Introduction to Stacks - Basics and Operations | Data Structures and Algorithms Day #6

## Learn the basics of the stack data structure with operations like push, pop, and peek

Stacks are a **fundamental** **data structure** in programming, offering a simple yet powerful way to manage data. They are widely used in algorithms, from **expression parsing to undo operations** in text editors. In this article, we’ll explore the **basics of stacks**, demonstrate key **operations like push, pop, and peek** with **Python and JavaScript examples**, and discuss their real-world applications. By the end, you’ll understand how to implement a stack, its time complexity, and common use cases.

**What is a Stack?**

A **stack data structure** is a collection of elements that follows the **LIFO (Last-In, First-Out) principle**. This means that the last element added to the stack is the first one to be removed. Imagine a stack of plates: the plate placed on top is the first to be removed.

**Key Characteristics of Stacks**

**LIFO Principle:**The last inserted element is accessed first.**Sequential Access:**You can only access the topmost element without removing others.**Dynamic Size:**Can grow or shrink dynamically based on operations.

**Operations on Stacks**

Here are the core operations performed on a stack:

**1. Push Operation**

Adds an element to the top of the stack.

**Python Example:**

```
class Stack:
def __init__(self):
self.items = []
def push(self, item):
self.items.append(item)
stack = Stack()
stack.push(5) # Adds 5 to the stack
stack.push(10) # Adds 10 on top
print(stack.items) # Output: [5, 10]
```

**JavaScript Example:**

```
class Stack {
constructor() {
this.items = [];
}
push(item) {
this.items.push(item);
}
}
const stack = new Stack();
stack.push(5); // Adds 5 to the stack
stack.push(10); // Adds 10 on top
console.log(stack.items); // Output: [5, 10]
```

**2. Pop Operation**

Removes the top element from the stack.

**Python Example:**

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

**JavaScript Example:**

```
pop() {
return this.items.length > 0 ? this.items.pop() : null;
}
```

**3. Peek Operation**

Returns the top element without removing it.

**Python Example:**

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

**JavaScript Example:**

```
peek() {
return this.items.length > 0 ? this.items[this.items.length - 1] : null;
}
```

**4. isEmpty Operation**

Checks if the stack is empty.

**Python Example:**

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

**JavaScript Example:**

```
isEmpty() {
return this.items.length === 0;
}
```

**Diagram: Stack Operations**

Below is a visual representation of how **push and pop operations** work on a stack.

**Push:**Add elements to the top.**Pop:**Remove the top element.

**Time Complexity** **of Stack Operations**

Operation | Time Complexity |

Push | O(1) |

Pop | O(1) |

Peek | O(1) |

isEmpty | O(1) |

Since all operations only involve the **top element**, stacks are extremely efficient with **O(1) time complexity**.

**Real-World Applications of Stacks**

Stacks are used in various programming scenarios, including:

**Undo/Redo Operations:**Text editors use stacks to track user actions.**Expression Parsing:**Stacks help in evaluating arithmetic expressions or handling parentheses.**Call Stacks:**Programming languages manage function calls using a stack.**Browser History:**Backtracking through visited pages uses a stack.

**Types of Stacks: Static vs. Dynamic**

Static Stack | Dynamic Stack |

Fixed-size, limited space | Grows dynamically with new elements |

Example: Array-based stack | Example: Linked list-based stack |

**Common Misconceptions about Stacks**

**"Stacks are only for storing integers."**

Stacks can store any data type, including strings and objects.**"Stacks are always inefficient."**

While not ideal for all scenarios, stacks offer**O(1) time complexity**for most operations, making them highly efficient for specific use cases.

For more on related data structures, check out:

**FAQ Section**

**What is the difference between push and pop operations?**

**Push:**Adds an element to the top of the stack.**Pop:**Removes the top element from the stack.

**How is a stack implemented in** **Python****?**

Stacks in Python can be implemented using **lists** or the **deque module** from the collections library.

**What are the common uses of stacks in real-world applications?**

Stacks are used in **undo operations**, **expression parsing**, and **managing function calls** through the **call stack**.

**Conclusion**

Stacks are an essential data structure that offers **simple and efficient data management** through the **LIFO principle**. With operations like **push, pop, and peek**, stacks are widely used in both **theoretical and practical applications**, such as **expression parsing** and **browser history management**.

Try implementing a **stack** in your preferred programming language using the **examples above**. Understanding how stacks work will not only improve your knowledge of data structures but also help you solve algorithmic problems more efficiently.