Peek Front Element of Queue in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the front element of the queue.

DSA C

int peekFront(struct Queue* q) {
    if (q->front == -1) {
        return -1; // Queue is empty
    }
    return q->array[q->[1]];
}

Drag options to blanks, or click blank then click option'

Acapacity

Brear

Csize

Dfront

Attempts:

3 left

💡 Hint

Common Mistakes

Using q->array[q->rear] instead of q->array[q->front]

Returning q->size or q->capacity instead of an element

Not checking if the queue is empty before accessing

The front element of the queue is at index 'front' in the array.

2fill in blank

medium

Complete the code to check if the queue is empty before peeking.

DSA C

int peekFront(struct Queue* q) {
    if (q->[1] == -1) {
        return -1; // Queue is empty
    }
    return q->array[q->front];
}

Drag options to blanks, or click blank then click option'

Arear

Bsize

Cfront

Dcapacity

Attempts:

3 left

💡 Hint

Common Mistakes

Checking rear instead of front for emptiness

Checking size or capacity which may not reflect emptiness

Not returning -1 when queue is empty

The queue is empty if the front index is -1.

3fill in blank

hard

Fix the error in the peek function to correctly handle empty queue.

DSA C

int peekFront(struct Queue* q) {
    if ([1]) {
        return -1; // Queue is empty
    }
    return q->array[q->front];
}

Drag options to blanks, or click blank then click option'

Aq->rear == -1

Bq->front == -1

Cq->front == q->rear

Dq->size == 0

Attempts:

3 left

💡 Hint

Common Mistakes

Checking front == 0 instead of front == -1

Using rear or size incorrectly to check emptiness

The queue is empty when front is -1, not 0.

4fill in blank

hard

Fill both blanks to correctly implement peekFront with empty check and return front element.

DSA C

int peekFront(struct Queue* q) {
    if (q->[1] == -1) {
        return -1; // Queue is empty
    }
    return q->array[q->[2]];
}

Drag options to blanks, or click blank then click option'

Afront

Brear

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Using rear instead of front for empty check

Returning element at rear instead of front

Check if front is -1 to detect empty queue, then return element at front index.

5fill in blank

hard

Fill all three blanks to implement peekFront with empty check, return front element, and print error if empty.

DSA C

int peekFront(struct Queue* q) {
    if (q->[1] == -1) {
        printf("[2]\n");
        return [3];
    }
    return q->array[q->front];
}

Drag options to blanks, or click blank then click option'

Afront

BQueue is empty

C-1

Drear

Attempts:

3 left

💡 Hint

Common Mistakes

Not printing error message when queue is empty

Returning wrong error code

Checking wrong index for emptiness

Check front == -1 for empty, print message, and return -1 as error code.

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