DATA STRUCTURES
AND ALGORITHMS
STACK
Ali Mobin Memon
What is Stack?
• Its Linear / non-linear data structure. But it cannot be both at the
same time
• Its Static and Dynamic. But it cannot be both at the same time
• Its continuous as well as non-continuous stream of data. But it
cannot be both at the same time
• Depends on way it is executed
• Via linked list
• Via Array
What is Stack - Continued
• It follows LIFO ( Last in first out )
• The first on top of stack of plates is the one that is picked first also
the last one that is placed on stack
• It features two operations
• Push
Means to insert a new item
• Pop
Means to delete an item
Stack Operations
• Key Operations:
• Push: Add an element to the top of the stack.
• Pop: Remove the element from the top of the stack.
• Peek or Top: Look at the top element of the stack
without removing it.
• is Empty: Check if the stack is empty.
Stack Operations
• Applications in DSA:
• Expression evaluation (e.g., postfix, prefix expressions).
• Backtracking algorithms depth-first search (DFS).
• Undo mechanisms text editors.
• Function call management recursion (function calls are
handled using a call stack).
Note: This list does not mean its best in these applications
import java.util.Stack;
public class StackExample {
public static void main(String[] args) {
// Creating a stack of integers
Stack<Integer> stack = new Stack<>();
// Pushing elements onto the stack
stack.push(10); // Stack: [10]
stack.push(20); // Stack: [10, 20]
stack.push(30); // Stack: [10, 20, 30]
// Displaying the top element
System.out.println("Top element: " + stack.peek()); // Outputs 30
// Popping the top element
stack.pop(); // Stack: [10, 20]
// Displaying the top element after popping
System.out.println("Top element after pop: " + stack.peek()); // Outputs
20
// Checking if the stack is empty
System.out.println("Is stack empty? " + stack.isEmpty()); // Outputs false
}
}
Types of Stack
• Fixed Size Stack:
• fixed size stack has a fixed size and cannot grow or shrink dynamically.
• If the stack is full and an attempt is made to add an element to it, an
overflow error occurs.
• If the stack is empty and an attempt is made to remove an element
from it, an underflow error occurs.
• For example, using Array
• Dynamic Size Stack:
• A dynamic size stack can grow or shrink dynamically.
• When the stack is full, it automatically increases its size to
accommodate the new element, and when the stack is empty, it
decreases its size.
• For example, using Linked List
Stack-Array
• The push operation
• It is implemented by incrementing the index of the top
element and storing the new element at that index.
• In Array overflow issue!
• The pop operation
• It is implemented by returning the value stored at the top
index and then decrementing the index of the top element.
• Underflow issue can occur
Stack-Array
Stack - Array
int pop()
Stack-Array {
if (top < 0) {
Import java.util.Stack; System.out.println("Stack Underflow");
return 0;
}
class Stack { else {
static final int MAX = 1000; int x = a[top--];
a[top--] = null;
int top; return x;
int a[] = new int[MAX]; }
}
// Maximum size of Stack
boolean push(int x)
Stack()
{
{
if (top >= (MAX - 1)) {
top = -1;
System.out.println("Stack Overflow");
}
return false;
}
boolean isEmpty()
{ else {
return (top < 0); a[++top] = x;
}
System.out.println(x + " pushed into stack");
return true;
Stack-Array
int peek() class Main {
{ public static void main(String args[])
if (top < 0) {
System.out.println("Stack Underflow"); {
return 0; Stack s = new Stack();
}
s.push(10);
else {
int x = a[top]; s.push(20);
return x; s.push(30);
}
} System.out.println(s.pop() + " Popped
from stack");
void print(){ System.out.println("Top element is :" +
for(int i = top;i>-1;i--){ s.peek());
System.out.print(" "+ a[i]);
System.out.print("Elements present in
} stack :");
s.print();
} }
}
Stack-Array Advantages & Disadvantages
• Advantages of Array Implementation:
• Memory is saved as pointers are not involved the bytes stored
for pointers are non-existing
• Disadvantages of Array Implementation:
• It is not dynamic. It doesn’t grow and shrink depending on
needs at runtime. But in case of dynamic sized arrays like
vector in C++, list in Python, Array List in Java, stacks can
grow and shrink with array implementation as well.
• The total size of the stack must be defined
beforehand.
Stack-Link list
• The push operation
• It is implemented by creating a new node with the new
element and setting the next pointer of the current top node to
the new node.
• No overflow issue!
• The pop operation
• It is implemented by setting the next pointer of the current top
node to the next node and returning the value of the current
top node.
• No underflow issue!
Stack-Link list
Reference to diagrams in ppt notes tab
Stack-Link list
example
Stack-Link list
Push or Pop at end of linked list
Stack-Link list
Push or Pop at end of linked list
Stack-Link list
Push or Pop at beginning of linked list
Stack-Link list
Push or Pop at beginning of linked list
Stack- Linked List
public class StackAsLinkedList { public void push(int data)
{
StackNode root; StackNode newNode = new StackNode(data);
static class StackNode { if (root == null) {
root = newNode;
int data; }
StackNode next; else {
StackNode temp = root;
StackNode(int data) { this.data = data; } root = newNode;
} newNode.next = temp;
}
System.out.println(data + " pushed to stack");
public boolean isEmpty() }
{ public int peek()
if (root == null) { {
if (root == null) {
return true; System.out.println("Stack is empty");
} return Integer.MIN_VALUE;
}
else else {
return false; return root.data;
}
} }
Stack-Array
public static void main(String[] args)
{
StackAsLinkedList sll = new StackAsLinkedList();
sll.push(10);
sll.push(20);
sll.push(30);
System.out.println(sll.pop() + " popped from stack");
System.out.println("Top element is " + sll.peek());
sll.push(10);
sll.push(20);
sll.push(30);
System.out.println(sll.pop() + " popped from stack");
System.out.println("Top element is " + sll.peek());
}
}
Stack-Link list Advantages & Disadvantages
• Advantages of Linked List implementation:
• The linked list implementation of a stack can grow and shrink
according to the needs at runtime.
• It is used in many virtual machines like JVM
• Disadvantages of Linked List implementation:
• Requires extra memory due to the involvement of pointers.
• Random accessing is not possible in stack.
Next Week
• 1 hour test before break
• Data structure
• Array
• linked list
• Stack
• Assignment 1 announcement
• To be decided that day
• Deadline: 2 weeks after announcement
Reference
• Geek for Geeks
• CHAT-GPT
• Prep insta
THANK YOU
