Peek Front Element of Queue in DSA C - Execution Trace

Concept Flow - Peek Front Element of Queue

Start with Queue

↓

Check if Queue is empty?

Yes→Return error or NULL

No↓

Access front element

↓

Return front element value

↓

Done

The flow checks if the queue is empty. If not, it accesses and returns the front element without removing it.

Execution Sample

DSA C

int peekFront(Queue* q) {
    if (q->front == NULL) return -1; // empty
    return q->front->data;
}

This code returns the value at the front of the queue or -1 if the queue is empty.

Execution Table

Step	Operation	Nodes in Queue	Pointer Changes	Visual State
1	Start with queue having nodes 10 -> 20 -> 30	10 -> 20 -> 30 -> NULL	front points to node with 10, rear points to node with 30	[front]10 -> 20 -> 30 -> NULL
2	Check if queue is empty (front == NULL?)	10 -> 20 -> 30 -> NULL	No pointer changes	[front]10 -> 20 -> 30 -> NULL
3	Access front element data	10 -> 20 -> 30 -> NULL	No pointer changes	[front]10 -> 20 -> 30 -> NULL
4	Return front element value: 10	10 -> 20 -> 30 -> NULL	No pointer changes	[front]10 -> 20 -> 30 -> NULL

💡 Peek operation ends after returning front element value without modifying queue.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
front	Node(10)	Node(10)	Node(10)	Node(10)	Node(10)
rear	Node(30)	Node(30)	Node(30)	Node(30)	Node(30)
front->data	10	10	10	10	10

Key Moments - 3 Insights

Why do we check if front == NULL before peeking?

Because if front is NULL, the queue is empty and there is no element to peek. This prevents accessing invalid memory. See execution_table step 2.

Does peeking remove the front element from the queue?

No, peeking only reads the front element's value without changing the queue structure or pointers. See execution_table steps 3 and 4.

What happens if we try to peek an empty queue?

The function returns -1 (or an error) indicating the queue is empty, as shown in the code and explained in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the front->data value at step 3?

A 20

B 10

C 30

D -1

💡 Hint

Check the 'front->data' row in variable_tracker after step 3.

At which step does the code confirm the queue is not empty?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Operation' column in execution_table where the empty check happens.

If the queue was empty, what would the function return?

A -1

B 10

C 0

D NULL

💡 Hint

See the code in execution_sample and explanation in key_moments about empty queue.

Concept Snapshot

Peek Front Element of Queue:
- Check if queue is empty (front == NULL)
- If empty, return error (e.g., -1)
- Else, return front->data without removing it
- Queue remains unchanged after peek
- Useful to see next element without dequeueing

Full Transcript

Peeking the front element of a queue means looking at the first element without removing it. The code first checks if the queue is empty by seeing if the front pointer is NULL. If it is empty, it returns -1 to indicate no element is present. Otherwise, it returns the data stored in the front node. The queue structure and pointers do not change during this operation. This lets us see the next element to be dequeued 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