Peek Front Element of Queue in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of peeking the front element in this queue?

Consider a queue implemented using an array with front at index 0 and rear at index 3. The queue elements are [10, 20, 30, 40]. What will be the output of the peek operation?

DSA C

int queue[] = {10, 20, 30, 40};
int front = 0;
int rear = 3;
int peek = queue[front];
printf("%d\n", peek);

A 30

B 40

C 10

D 0

💡 Hint

The front element is the first element inserted in the queue.

In a queue, the front points to the first element inserted. Here, front is 0, so queue[front] is 10.

❓ Predict Output

intermediate

What happens when peeking an empty queue?

Given a queue with front = -1 and rear = -1 indicating it is empty, what will happen if we try to peek the front element?

DSA C

int front = -1;
int rear = -1;
if(front == -1) {
    printf("Queue is empty\n");
} else {
    printf("%d\n", queue[front]);
}

A Queue is empty

B 0

C Garbage value

D Segmentation fault

💡 Hint

Check the condition that indicates the queue is empty before peeking.

When front is -1, the queue is empty, so peeking should not access any element and print 'Queue is empty'.

🔧 Debug

advanced

Why does this peek function cause an error?

This peek function is intended to return the front element of a queue. Identify the error and its cause.

DSA C

int peek(int queue[], int front, int rear) {
    if(front > rear) {
        printf("Queue is empty\n");
        return -1;
    }
    return queue[rear];
}

A Incorrect empty queue condition causes runtime error

B Returns rear element instead of front element

C Returns front element correctly

D Syntax error due to missing semicolon

💡 Hint

Peek should return the element at the front index, not rear.

The function returns queue[rear], which is the last element, not the front. It should return queue[front].

🧠 Conceptual

advanced

What is the time complexity of peeking the front element in a queue?

Assuming a queue is implemented using a linked list or array, what is the time complexity of the peek operation?

A O(1)

B O(n)

C O(log n)

D O(n^2)

💡 Hint

Peek just returns the front element without traversal.

Peek accesses the front element directly, so it takes constant time O(1).

🚀 Application

expert

After these operations, what is the front element of the queue?

A queue is initially empty. We perform enqueue(5), enqueue(10), dequeue(), enqueue(15), dequeue(), enqueue(20). What is the front element now?

DSA C

Operations:
1. enqueue(5)
2. enqueue(10)
3. dequeue()
4. enqueue(15)
5. dequeue()
6. enqueue(20)

Assume standard FIFO queue behavior.

A 10

B 5

C 20

D 15

💡 Hint

Track the queue state after each operation carefully.

After enqueue(5) and enqueue(10), queue is [5,10]. dequeue removes 5, queue is [10]. enqueue(15) adds 15, queue is [10,15]. dequeue removes 10, queue is [15]. enqueue(20) adds 20, queue is [15,20]. Front is 15.

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