Master the essential stack operations: push, pop, peek, and isEmpty. Learn how to implement these operations efficiently and understand their time complexities.

Learning Objectives

Push Operation

Add elements to the stack

Pop Operation

Remove elements from stack

Peek/Top

View top element without removing

Helper Methods

Check empty status and size

Essential Stack Operations

A stack provides a limited set of operations that maintain the LIFO principle. These operations are simple but powerful enough to solve many complex problems.

Push Operation

Add an element to the top of the stack

Time Complexity: O(1)

Pop Operation

Remove and return the top element

Time Complexity: O(1)

Peek/Top Operation

View the top element without removing it

Time Complexity: O(1)

isEmpty Operation

Check if the stack is empty

Time Complexity: O(1)

Stack Interface

class Stack <T>:

push(item: T): void

pop(): T | undefined

peek(): T | undefined

isEmpty(): boolean

size(): number

}

Important: All operations work on the top of the stack only!

Push Operation Deep Dive

How Push Works

The push operation adds a new element to the top of the stack. It increases the stack size by one and ensures the new element becomes the most recently added item.

Push Algorithm:

1. Check if stack has space (if using fixed-size)

2. Add element to the top position

3. Increment the stack pointer/size

4. Return success (if needed)

Array Implementation

push(item) {

if (top < maxSize - 1) {

arr[++top] = item;

} else {

throw "Stack Overflow";

}

Linked List Implementation

push(item) {

newNode = new Node(item);

newNode.next = top;

top = newNode;

size++;

}

Push Example

Initial: []

Empty stack

push(5)

[5] ← top

Size: 1

push(3)

[5, 3] ← top

Size: 2

push(8)

[5, 3, 8] ← top

Size: 3

Pop Operation Deep Dive

How Pop Works

The pop operation removes and returns the top element from the stack. It decreases the stack size by one and makes the second-to-top element the new top.

Pop Algorithm:

1. Check if stack is not empty

2. Save the top element to return

3. Remove the top element

4. Decrement the stack pointer/size

5. Return the saved element

Array Implementation

pop() {

if (top >= 0) {

return arr[top--];

} else {

throw "Stack Underflow";

}

Linked List Implementation

pop() {

if (top != null) {

item = top.data;

top = top.next;

size--;

return item;

}

Pop Example

[5, 3, 8] ← top

Size: 3

pop() returns 8

[5, 3] ← top

Size: 2

pop() returns 3

[5] ← top

Size: 1

pop() returns 5

[] (empty)

Size: 0

Helper Operations

Peek/Top Operation

View the top element without removing it from the stack.

peek() {

if (!isEmpty()) {

return arr[top];

}

return null;

}

Time: O(1) | Space: O(1)

isEmpty Operation

Check whether the stack contains any elements.

isEmpty() {

return top == -1;

// or size == 0

}

Time: O(1) | Space: O(1)

Size Operation

Get the current number of elements in the stack.

size() {

return top + 1;

// or return size

}

Time: O(1) | Space: O(1)

Complete Stack Usage Example

Stack<Integer> stack = new Stack<>();

// Initial state

stack.isEmpty(); // returns true

stack.size(); // returns 0

// Adding elements

stack.push(10);

stack.push(20);

stack.push(30);

// Checking state

stack.size(); // returns 3

stack.peek(); // returns 30

stack.isEmpty(); // returns false

// Removing elements

stack.pop(); // returns 30

stack.peek(); // returns 20

Previous: Stack Fundamentals Next: Stack Applications