Enqueue Operation in DSA C++

Mental Model

Adding an item to the end of a queue means placing it behind all the others waiting.

Analogy: Imagine standing in a line at a coffee shop. When a new person arrives, they go to the back of the line, not in front or the middle.

front -> 10 -> 20 -> 30 -> null ← rear
↑ front pointer
                 ↑ rear pointer

Dry Run Walkthrough

Input: queue: 10 -> 20 -> 30 -> null, enqueue value 40

Goal: Add the value 40 to the end of the queue so it becomes 10 -> 20 -> 30 -> 40 -> null

Step 1: Create a new node with value 40 and next pointer null

new_node: 40 -> null

Why: We need a new node to hold the value before adding it to the queue

Step 2: Link the current rear node (30) to the new node

10 -> 20 -> 30 -> [rear->40] -> null

Why: The last node must point to the new node to keep the chain intact

Step 3: Update the rear pointer to the new node

front -> 10 -> 20 -> 30 -> 40 -> null ← rear

Why: Rear must always point to the last node for future enqueue operations

Result:

front -> 10 -> 20 -> 30 -> 40 -> null ← rear

Annotated Code

DSA C++

#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

class Queue {
private:
    Node* front;
    Node* rear;
public:
    Queue() : front(nullptr), rear(nullptr) {}

    void enqueue(int val) {
        Node* newNode = new Node(val); // create new node
        if (rear == nullptr) { // queue empty
            front = rear = newNode; // front and rear point to new node
            return;
        }
        rear->next = newNode; // link last node to new node
        rear = newNode; // update rear to new node
    }

    void printQueue() {
        Node* temp = front;
        while (temp != nullptr) {
            cout << temp->data << " -> ";
            temp = temp->next;
        }
        cout << "null" << endl;
    }
};

int main() {
    Queue q;
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.enqueue(40);
    q.printQueue();
    return 0;
}

Node* newNode = new Node(val); // create new node

create a new node to hold the value to add

if (rear == nullptr) { // queue empty

check if queue is empty to initialize front and rear

front = rear = newNode; // front and rear point to new node

set both front and rear to new node when queue was empty

rear->next = newNode; // link last node to new node

connect current rear node to new node to extend queue

rear = newNode; // update rear to new node

move rear pointer to new last node

Output

10 -> 20 -> 30 -> 40 -> null

Complexity Analysis

Time: O(1) because enqueue adds the new node directly at the rear without traversing the queue

Space: O(1) because only one new node is created regardless of queue size

vs Alternative: Compared to using an array where adding at the end might require shifting elements (O(n)), linked list enqueue is faster and simpler

Edge Cases

empty queue

front and rear both point to the new node after enqueue

DSA C++

if (rear == nullptr) { // queue empty

When to Use This Pattern

When you see a problem asking to add items in order and remove in the same order, think of the enqueue operation to add at the end of a queue.

Common Mistakes

Mistake: Not updating the rear pointer after adding the new node
Fix: Always set rear = newNode after linking the new node

Mistake: Not handling the empty queue case, causing front to remain null
Fix: Check if rear is null and set front and rear to newNode if true

Summary

Adds a new element to the end of the queue.

Use when you want to insert items in the order they arrive.

Remember to update the rear pointer and handle empty queue separately.

Practice

1. What does the enqueue operation do in a queue data structure?

easy

A. Returns the size of the queue

B. Removes an element from the front of the queue

C. Checks if the queue is empty

D. Adds an element to the end of the queue

Solution

1. Step 1: Understand the queue structure

   A queue works like a line where elements are added at the back and removed from the front.

2. Step 2: Define the enqueue operation

   Enqueue means adding a new element to the end of the queue to wait its turn.

3. Final Answer:

   Adds an element to the end of the queue -> Option D

4. Quick Check:

   Enqueue = Add at end [OK]

Hint: Enqueue always adds at the back of the queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue (removal)
• Thinking enqueue removes elements
• Mixing enqueue with checking queue size

2. Which of the following is the correct syntax to enqueue an element 5 into a queue named q in C++ STL?

easy

A. q.push(5);

B. q.add(5);

C. q.enqueue(5);

D. q.insert(5);

Solution

1. Step 1: Recall C++ STL queue methods

   The standard queue in C++ uses push() to add elements at the back.

2. Step 2: Match the correct method

   enqueue is not a method in STL queue; push is used instead.

3. Final Answer:

   q.push(5); -> Option A

4. Quick Check:

   STL queue uses push() to enqueue [OK]

Hint: Use push() to add elements in C++ STL queue [OK]

Common Mistakes:

• Using enqueue() which is not in STL queue
• Using add() or insert() which are not queue methods
• Confusing push() with pop()

3. What will be the output of the following C++ code snippet?

std::queue<int> q;
q.push(10);
q.push(20);
q.push(30);
q.pop();
std::cout << q.front();

medium

A. 10

B. Compilation error

C. 20

D. 30

Solution

1. Step 1: Trace the enqueue operations

   Elements 10, 20, 30 are added in order: queue = [10, 20, 30]

2. Step 2: Apply the dequeue operation

   pop() removes the front element 10, so queue = [20, 30]

3. Step 3: Check the front element

   front() now returns 20, the new front.

4. Final Answer:

   20 -> Option C

5. Quick Check:

   After pop, front = 20 [OK]

Hint: pop removes front; front() shows new front [OK]

Common Mistakes:

• Assuming front remains 10 after pop
• Confusing pop with removing from back
• Expecting output 30 instead of 20

4. Identify the error in the following code that tries to enqueue an element into a queue:

std::queue<int> q;
q.enqueue(15);

medium

A. Missing #include <queue>

B. enqueue is not a member function of std::queue

C. Queue must be initialized with size

D. Cannot enqueue integer values

Solution

1. Step 1: Check std::queue methods

   std::queue does not have an enqueue method; it uses push to add elements.

2. Step 2: Identify the error cause

   Calling enqueue causes a compilation error because the method does not exist.

3. Final Answer:

   enqueue is not a member function of std::queue -> Option B

4. Quick Check:

   Use push() not enqueue() in std::queue [OK]

Hint: std::queue uses push(), not enqueue() [OK]

Common Mistakes:

• Assuming enqueue() exists in std::queue
• Thinking queue needs size at initialization
• Believing integers cannot be enqueued

5. You have a queue initially empty. You perform these operations:

enqueue(1)
enqueue(2)
dequeue()
enqueue(3)
dequeue()
enqueue(4)

What is the final state of the queue (front to back)?

hard

A. 3 -> 4 -> null

B. 2 -> 3 -> 4 -> null

C. 1 -> 3 -> 4 -> null

D. 4 -> null

Solution

1. Step 1: Perform operations step-by-step

   Start empty: []
   enqueue(1): [1]
   enqueue(2): [1, 2]
   dequeue(): removes 1 -> [2]
   enqueue(3): [2, 3]
   dequeue(): removes 2 -> [3]
   enqueue(4): [3, 4]

2. Step 2: Write final queue state

   Queue front is 3, then 4, then null (end).

3. Final Answer:

   3 -> 4 -> null -> Option A

4. Quick Check:

   After operations, queue = 3,4 [OK]

Hint: Track each enqueue/dequeue step carefully [OK]

Common Mistakes:

• Forgetting to remove elements on dequeue
• Mixing order of elements after operations
• Assuming dequeue removes from back