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 -> [1] -> [2] -> [3] -> null
           ↑ peek here

Dry Run Walkthrough

Input: queue: 1 -> 2 -> 3, peek front element

Goal: To see the first element in the queue without removing it

Step 1: Check if the queue is empty

front -> [1] -> [2] -> [3] -> null

Why: We must ensure there is an element to peek at

Step 2: Access the front element's value

front -> [1] -> [2] -> [3] -> null

Why: The front element holds the value we want to peek

Step 3: Return the front element's value without removing it

front -> [1] -> [2] -> [3] -> null

Why: Peeking does not change the queue structure

Result:

front -> [1] -> [2] -> [3] -> null
peeked value = 1

Annotated Code

DSA C

#include <stdio.h>
#include <stdlib.h>

// Node structure for queue
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Queue structure with front and rear pointers
typedef struct Queue {
    Node* front;
    Node* rear;
} Queue;

// Create a new empty queue
Queue* createQueue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = NULL;
    q->rear = NULL;
    return q;
}

// Add element to the rear of the queue
void enqueue(Queue* q, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
        return;
    }
    q->rear->next = newNode;
    q->rear = newNode;
}

// Peek the front element without removing it
int peekFront(Queue* q) {
    if (q->front == NULL) {
        printf("Queue is empty\n");
        return -1; // Indicates empty queue
    }
    return q->front->data; // Return front value without dequeue
}

int main() {
    Queue* q = createQueue();
    enqueue(q, 1);
    enqueue(q, 2);
    enqueue(q, 3);

    int frontValue = peekFront(q);
    if (frontValue != -1) {
        printf("Peeked value = %d\n", frontValue);
    }

    return 0;
}

if (q->front == NULL) {

Check if queue is empty to avoid errors

return q->front->data;

Return the value at the front without removing it

Output

Peeked value = 1

Complexity Analysis

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

Space: O(1) because no extra space is used during peek operation

vs Alternative: Compared to dequeue which removes the element and may require pointer updates, peek is faster and simpler as it only reads the front value

Edge Cases

Empty queue

Function prints 'Queue is empty' and returns -1 to indicate no element to peek

DSA C

if (q->front == NULL) {

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 check the front element safely.

Common Mistakes

Mistake: Trying to peek when the queue is empty without checking, causing a null pointer access
Fix: Always check if the front pointer is NULL before accessing its data

Summary

Peek returns the front element of the queue without removing it.

Use peek when you want to know the next item to process but keep the queue unchanged.

The key is to access the front pointer's data safely without modifying the queue.

Practice

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

easy

A. Returns the front element without removing it

B. Removes the front element

C. Adds an element to the back

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

   Removing is done by dequeue, adding by enqueue, and checking empty is a separate check.

3. Final Answer:

   Returns the front element without removing it -> Option A

4. Quick Check:

   Peek = front element without removal [OK]

Hint: Peek shows front without removing [OK]

Common Mistakes:

• Confusing peek with dequeue
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following is the correct C syntax to peek the front element of a queue named q implemented with an array and front index front?

easy

A. int x = q[front];

B. int x = q[rear];

C. int x = q[front + 1];

D. int x = q[0];

Solution

1. Step 1: Identify front element in array queue

   The front element is at index front in the array q.

2. Step 2: Check other options

   rear points to the back, front + 1 is next element, q[0] may not be front if front moved.

3. Final Answer:

   int x = q[front]; -> Option A

4. Quick Check:

   Peek front = q[front] [OK]

Hint: Peek uses front index, not rear or zero [OK]

Common Mistakes:

• Using rear index instead of front
• Adding 1 to front index incorrectly
• Assuming front is always zero

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

int q[5] = {10, 20, 30, 40, 50};
int front = 2;
printf("%d", q[front]);

medium

A. 10

B. 20

C. 30

D. 40

Solution

1. Step 1: Identify the element at index front

   Index 2 in array q is the third element, which is 30.

2. Step 2: Confirm output of printf

   Printing q[front] prints 30.

3. Final Answer:

   30 -> Option C

4. Quick Check:

   q[2] = 30 [OK]

Hint: Array index starts at 0, so q[2] is third element [OK]

Common Mistakes:

• Confusing index 2 with value 20
• Printing q[front + 1] by mistake
• Assuming front is zero

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

int q[3] = {5, 10, 15};
int front = 3;
printf("%d", q[front]);

medium

A. Queue array is empty

B. front index is out of bounds

C. printf syntax error

D. No error, code is correct

Solution

1. Step 1: Check front index validity

   Array q has indices 0 to 2. front = 3 is outside bounds.

2. Step 2: Understand consequences

   Accessing q[3] causes undefined behavior or runtime error.

3. Final Answer:

   front index is out of bounds -> Option B

4. Quick Check:

   front must be within 0 to 2 [OK]

Hint: Front index must be inside array bounds [OK]

Common Mistakes:

• Ignoring array bounds
• Assuming front can be equal to array size
• Thinking printf syntax is wrong

5. Given a circular queue implemented with array q[5], front index front = 4, and rear index rear = 2, which expression correctly peeks the front element?

hard

A. q[front]

B. q[rear]

C. q[(rear + 1) % 5]

D. q[(front + 1) % 5]

Solution

1. Step 1: Understand circular queue front

   In a circular queue, the front element is at index (front + 1) % size, because front points to the last dequeued position.

2. Step 2: Check modulo usage

   Modulo is used to wrap around the array indices correctly.

3. Final Answer:

   q[(front + 1) % 5] -> Option D

4. Quick Check:

   Peek front = q[(front + 1) % size] in circular queue [OK]

Hint: In circular queue, front points behind the front element [OK]

Common Mistakes:

• Using q[front] directly in circular queue
• Confusing rear with front
• Assuming front is always zero