Peek Front Element of Queue in DSA C++

Mental Model

A queue is like a line where the first person in is the first person out. Peeking means looking at the first person without removing them.

Analogy: Imagine waiting in line at a coffee shop. Peeking is like glancing at the person at the front of the line to see who is next without letting them leave the line.

front -> [10] -> 20 -> 30 -> null
rear  ↑

Dry Run Walkthrough

Input: queue: 10 -> 20 -> 30, peek front element

Goal: To see the value at the front of the queue without removing it

Step 1: Access the front pointer of the queue

front -> [10] -> 20 -> 30 -> null
rear  ↑

Why: We need to look at the first element to peek

Step 2: Read the value at the front node (10)

front -> [10] -> 20 -> 30 -> null
rear  ↑

Why: This is the element at the front without removing it

Result:

front -> [10] -> 20 -> 30 -> null
rear  ↑
Peeked value: 10

Annotated Code

DSA C++

#include <iostream>
#include <stdexcept>
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);
        if (!rear) {
            front = rear = newNode;
            return;
        }
        rear->next = newNode;
        rear = newNode;
    }

    int peek() {
        if (!front) {
            throw runtime_error("Queue is empty");
        }
        return front->data; // peek front value
    }

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

int main() {
    Queue q;
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.printQueue();
    cout << "Peeked value: " << q.peek() << endl;
    return 0;
}

return front->data; // peek front value

return the value at the front node without removing it

Output

10 -> 20 -> 30 -> null

Peeked value: 10

Complexity Analysis

Time: O(1) because peeking only reads the front element without traversal

Space: O(n) for storing n elements in the queue nodes

vs Alternative: Peeking is O(1) like dequeue in linked list queues, but does not remove the element

Edge Cases

empty queue

throws runtime error indicating queue is empty

DSA C++

if (!front) {
            throw runtime_error("Queue is empty");
        }

When to Use This Pattern

When you need to see the next item to process in a queue without removing it, use the peek operation to access the front element safely.

Common Mistakes

Mistake: Trying to peek when the queue is empty without checking causes a crash or undefined behavior.
Fix: Always check if the front pointer is null before accessing its data.

Summary

Peek returns the value at the front of the queue without removing it.

Use peek when you want to know the next element to process but keep it in the queue.

The key insight is that peeking reads the front pointer's data without changing the queue structure.

Practice

1. What does the peek() operation do in a queue?

easy

A. Removes the front element from the queue

B. Returns the front element without removing it

C. Adds an element to the back of the queue

D. Checks if the queue is empty

Solution

1. Step 1: Understand the peek operation

   The peek operation looks at the front element of the queue without changing the queue.

2. Step 2: Compare with other operations

   Unlike dequeue, peek does not remove the element; it only returns it.

3. Final Answer:

   Returns the front element without removing it -> Option B

4. Quick Check:

   peek() = front element [OK]

Hint: Peek shows front without removal [OK]

Common Mistakes:

• Confusing peek with dequeue
• Thinking peek adds elements
• Assuming peek empties queue

2. Which of the following is the correct syntax to peek the front element of a std::queue<int> named q in C++?

easy

A. q.front();

B. q.peek();

C. q.top();

D. q.getFront();

Solution

1. Step 1: Recall C++ queue methods

   In C++, std::queue uses front() to access the front element.

2. Step 2: Check other options

   peek() and getFront() are not valid methods; top() is for stacks, not queues.

3. Final Answer:

   q.front(); -> Option A

4. Quick Check:

   std::queue front() method = q.front() [OK]

Hint: Use front() to peek in std::queue [OK]

Common Mistakes:

• Using peek() which doesn't exist
• Using top() which is for stacks
• Trying getFront() which is invalid

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

#include <iostream>
#include <queue>

int main() {
    std::queue<int> q;
    q.push(10);
    q.push(20);
    q.push(30);
    std::cout << q.front() << std::endl;
    q.pop();
    std::cout << q.front() << std::endl;
    return 0;
}

medium

A. 10\n20

B. 10\n10

C. 20\n30

D. 30\n20

Solution

1. Step 1: Trace initial queue state

   After pushes, queue is [10 (front), 20, 30].

2. Step 2: Output front and pop

   First output is 10 (front). Then pop removes 10, queue becomes [20 (front), 30]. Next output is 20.

3. Final Answer:

   10\n20 -> Option A

4. Quick Check:

   First front=10, after pop front=20 [OK]

Hint: Pop removes front; peek shows new front [OK]

Common Mistakes:

• Not updating front after pop
• Printing popped element
• Confusing push order

4. Identify the error in this code snippet that tries to peek the front element of a queue:

#include <queue>
#include <iostream>

int main() {
    std::queue<int> q;
    q.push(5);
    std::cout << q.peek() << std::endl;
    return 0;
}

medium

A. q.push() requires two arguments

B. Queue is empty before peek

C. Using q.peek() which is not a valid method

D. Missing #include <vector>

Solution

1. Step 1: Check method used to peek

   The code uses q.peek(), but std::queue does not have a peek() method.

2. Step 2: Identify correct method

   The correct method to access the front element is q.front().

3. Final Answer:

   Using q.peek() which is not a valid method -> Option C

4. Quick Check:

   std::queue peek method = front() [OK]

Hint: Use front(), not peek(), to access front element [OK]

Common Mistakes:

• Using peek() method
• Assuming peek() exists
• Ignoring compiler errors

5. Given a queue q containing integers, write a C++ function int peekFrontOrDefault(std::queue<int>& q, int defaultVal) that returns the front element if the queue is not empty, or defaultVal if it is empty. What is the correct implementation?

hard

A. return q.front();

B. if (q.empty()) return q.front(); else return defaultVal;

C. if (q.size() > 1) return q.front(); else return defaultVal;

D. if (!q.empty()) return q.front(); else return defaultVal;

Solution

1. Step 1: Check if queue is empty

   Use q.empty() to verify if queue has elements.

2. Step 2: Return front or default value

   If not empty, return q.front(); otherwise, return defaultVal.

3. Final Answer:

   if (!q.empty()) return q.front(); else return defaultVal; -> Option D

4. Quick Check:

   Check empty before front() to avoid errors [OK]

Hint: Always check empty before front() to avoid errors [OK]

Common Mistakes:

• Not checking empty before front()
• Wrong condition on size
• Returning front when empty