Difference Between Stack and Queue: Definitions, Examples and Code

The difference between stack and queue is one of the first things every computer science student is asked, and one of the most commonly answered badly. Both are linear data structures, both store elements in a sequence, and both allow only restricted access. What separates them is a single rule about which element is allowed to leave first.

This guide explains what a stack and a queue actually are, gives ten clear differences in a comparison table, shows real world examples of each, includes working code in both C and Java, and covers how the two compare against a linked list. If your exam asks for only two or three points, there is a section for that as well.

What is a Stack?

A stack is a linear data structure in which insertion and deletion of elements take place at only one end, called the top, and it follows the Last In First Out principle. The element inserted most recently is the one removed first.

Think of a pile of plates in a canteen. You place a clean plate on top of the pile, and the next person takes a plate from the top. The plate at the bottom, placed first, is the last one to be used.

Stack operations:

Attempting to push onto a full stack causes overflow. Attempting to pop from an empty stack causes underflow.

What is a Queue?

A queue is a linear data structure in which insertion takes place at one end, called the rear, and deletion takes place at the other end, called the front, and it follows the First In First Out principle. The element inserted first is the one removed first.

Think of a line of people at a railway ticket counter. The person who joins the line first gets the ticket first, and a new person joins at the back of the line.

Queue operations:

Explain Stack and Queue With Example

The clearest way to see the difference is to insert the same three values into both structures and then remove them.

Stack, using push and pop:

push(10)  →  [10]
push(20)  →  [10, 20]
push(30)  →  [10, 20, 30]

pop()  →  returns 30
pop()  →  returns 20
pop()  →  returns 10

Output order: 30, 20, 10   (reverse of insertion)

Queue, using enqueue and dequeue:

enqueue(10)  →  [10]
enqueue(20)  →  [10, 20]
enqueue(30)  →  [10, 20, 30]

dequeue()  →  returns 10
dequeue()  →  returns 20
dequeue()  →  returns 30

Output order: 10, 20, 30   (same as insertion)

The data inserted was identical. Only the removal rule changed, and that single rule is what makes a stack a stack and a queue a queue.

10 Differences Between Stack and Queue

Differentiate Between Stack and Queue: Minimum Two Points Each

Short answer questions often ask for only two or three differences. Pick the ones that carry the most conceptual weight rather than the easiest to remember.

If asked for 2 differences:

1. A stack works on the Last In First Out principle, while a queue works on the First In First Out principle.
2. In a stack, insertion and deletion happen at the same end, called the top, whereas in a queue insertion happens at the rear and deletion at the front.

If asked for 3 differences, add:

3. A stack requires only one pointer, top, while a queue requires two pointers, front and rear.

These three cover the principle, the structure and the implementation, which is what an examiner is checking for. Adding operation names as a fourth point is a safe extra if the marks allow.

Explain Stack and Queue With One Real World Example Each

Stack: the browser back button. Every page you visit is pushed onto a stack. When you press back, the most recently visited page is popped and displayed. You always return to where you just came from, never to where you started, which is exactly LIFO behaviour.

Queue: a printer job list. When five people in a lab send documents to the same printer, the first document submitted is printed first. New jobs join at the rear of the list and the printer takes jobs from the front. Nobody’s document jumps the line, which is exactly FIFO behaviour.

Difference Between Stack, Queue and Linked List

This comparison confuses many students, because the three things are not the same kind of thing.

A stack and a queue are abstract data types. They define what operations are allowed and in what order, but not how the data is physically stored. A linked list is a data structure, a concrete way of storing elements as nodes connected by pointers.

In fact, both a stack and a queue can be implemented using a linked list, or using an array. The linked list is the container. The stack and queue are the rules imposed on that container.

The one line answer for an exam: a linked list allows insertion and deletion at any position, while a stack and a queue are restricted forms of a list that permit access only at fixed ends.

Difference Between Stack and Queue in Data Structure Using C

Stack implementation in C

#include <stdio.h>
#define MAX 100

int stack[MAX];
int top = -1;

void push(int value) {
    if (top == MAX - 1) {
        printf("Stack Overflow\n");
        return;
    }
    stack[++top] = value;
}

int pop() {
    if (top == -1) {
        printf("Stack Underflow\n");
        return -1;
    }
    return stack[top--];
}

int peek() {
    if (top == -1) {
        printf("Stack is empty\n");
        return -1;
    }
    return stack[top];
}

Notice that a single variable, top, controls the entire structure. It starts at minus one to indicate an empty stack, increases on every push and decreases on every pop.

Queue implementation in C

#include <stdio.h>
#define MAX 100

int queue[MAX];
int front = 0, rear = -1;

void enqueue(int value) {
    if (rear == MAX - 1) {
        printf("Queue Overflow\n");
        return;
    }
    queue[++rear] = value;
}

int dequeue() {
    if (front > rear) {
        printf("Queue Underflow\n");
        return -1;
    }
    return queue[front++];
}

Two variables are needed here, front and rear, and they move in the same direction. This creates a known weakness in the simple linear queue. After several enqueue and dequeue operations, rear reaches the end of the array while empty slots remain at the beginning, and no new element can be inserted even though space exists.

The circular queue solves this by wrapping the indices around using the modulus operator:

rear = (rear + 1) % MAX;
front = (front + 1) % MAX;

That single line is often worth a full mark on its own in a practical viva.

Stack vs Queue in Java

Java provides both structures in the java.util package, though the recommended classes have changed over the years.

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

public class StackVsQueue {
    public static void main(String[] args) {

        // Stack behaviour using ArrayDeque
        Deque<String> stack = new ArrayDeque<>();
        stack.push("A");
        stack.push("B");
        stack.push("C");
        System.out.println("Stack pop: " + stack.pop());   // prints C

        // Queue behaviour using LinkedList
        Queue<String> queue = new LinkedList<>();
        queue.add("A");
        queue.add("B");
        queue.add("C");
        System.out.println("Queue poll: " + queue.poll()); // prints A
    }
}

A few points worth knowing:

• The older java.util.Stack class extends Vector and is synchronised, which makes it slower. Modern Java practice prefers ArrayDeque for stack behaviour.
• Queue is an interface, not a class. It is commonly implemented by LinkedList, ArrayDeque or PriorityQueue.
• ArrayDeque implements the Deque interface, a double ended queue, which is why the same class can behave as both a stack and a queue depending on which methods you call.
• Use offer and poll instead of add and remove when you want the method to return a special value rather than throw an exception on failure.

Time Complexity Comparison

Both structures are equally efficient for their intended operations. The choice between them is never about speed. It is entirely about which element you need to retrieve next.

When to Use Which

Choose a stack when the most recent item is the one you need first. Function call management, undo and redo features, expression conversion from infix to postfix, checking for balanced parentheses, depth first search and backtracking problems all fit this pattern.

Choose a queue when items must be served in the order they arrived. CPU and disk scheduling, printer spooling, breadth first search in graphs, keyboard buffers and any waiting list all fit this pattern.

A useful test: ask whether reversing the order would be a bug or a feature. If reversal is desirable, use a stack. If it would be unfair or incorrect, use a queue.

Mistakes Students Make in the Exam

Writing that a queue uses one end. It uses two, and stating this incorrectly usually costs the whole mark.

Saying a stack is faster than a queue. Both are O(1) for insertion and deletion. There is no speed difference.

Calling a linked list a type of stack. It is the other way round. A stack can be implemented using a linked list.

Forgetting overflow and underflow conditions. Any implementation question expects both checks in the code.

Not mentioning the circular queue. If the question asks about limitations of a queue, the wasted space problem in a linear queue and its circular solution is the expected answer.

Where This Takes You Next

Stacks and queues look like small topics, but they sit underneath almost everything you will build later. The call stack decides how your recursive functions execute. Queues decide how operating systems schedule processes and how message systems handle traffic. Interviewers at product companies open with exactly these two structures because your answer tells them whether you understand data structures conceptually or only memorised them.

If data structures interest you and you are choosing a degree after PUC, this is the core of what a computer applications programme covers in its first year. You can look at the curriculum and lab facilities of the BCA programme at Trinity College to see how programming, data structures and database concepts are sequenced across the three years.

Frequently Asked Questions

What is the main difference between stack and queue?
The main difference is the order of removal. A stack follows Last In First Out, so the most recently added element is removed first. A queue follows First In First Out, so the earliest added element is removed first.

What are 2 differences between stack and queue?
First, a stack works on the LIFO principle while a queue works on FIFO. Second, in a stack both insertion and deletion happen at one end called the top, while in a queue insertion happens at the rear and deletion at the front.

Which is faster, a stack or a queue?
Neither. Both perform insertion and deletion in O(1) time. The choice between them depends on the order in which elements must be retrieved, not on performance.

Can a stack be implemented using a queue?
Yes. A stack can be simulated using two queues, or even a single queue by rotating elements after each insertion. It is a common interview question, though it is less efficient than a direct implementation.

What is the difference between stack, queue and linked list?
A stack and a queue are abstract data types defined by their access rules, LIFO and FIFO respectively. A linked list is a concrete data structure of nodes joined by pointers that allows insertion and deletion at any position, and it can be used to implement both a stack and a queue.

What is overflow and underflow in a stack?
Overflow occurs when a push operation is attempted on a stack that has reached its maximum capacity. Underflow occurs when a pop operation is attempted on an empty stack.

Which class should I use for a stack in Java?
ArrayDeque is preferred in modern Java. The older java.util.Stack class still works but extends Vector and is synchronised, which makes it slower for single threaded use.

Final Word

Stacks and queues differ by exactly one rule, and everything else follows from it. Learn the LIFO and FIFO principles properly, be able to trace three insertions and three deletions on paper for both, and write the C implementations from memory including the overflow and underflow checks. Once those three things are automatic, no question on this topic in any exam or interview will surprise you.

About the Author

Dr. Shama E M is the Principal of Trinity Institutions, Mysuru. With extensive experience in academic leadership and higher education, she works closely with faculty and students to strengthen conceptual clarity in computer applications and to guide students towards well informed academic and career decisions.