Queue Implementation Using Array in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Enqueue and Dequeue Operations

What is the printed state of the queue after these operations?

DSA C

typedef struct {
    int arr[5];
    int front;
    int rear;
} Queue;

void enqueue(Queue *q, int val) {
    if (q->rear == 4) return; // queue full
    q->rear++;
    q->arr[q->rear] = val;
}

int dequeue(Queue *q) {
    if (q->front > q->rear) return -1; // queue empty
    int val = q->arr[q->front];
    q->front++;
    return val;
}

int main() {
    Queue q = {.front = 0, .rear = -1};
    enqueue(&q, 10);
    enqueue(&q, 20);
    enqueue(&q, 30);
    dequeue(&q);
    enqueue(&q, 40);
    // Print queue from front to rear
    for (int i = q.front; i <= q.rear; i++) {
        printf("%d -> ", q.arr[i]);
    }
    printf("null\n");
    return 0;
}

A 10 -> 20 -> 30 -> 40 -> null

B 20 -> 30 -> 40 -> null

C 30 -> 40 -> null

D 20 -> 30 -> null

💡 Hint

Remember that dequeue removes the front element and front index moves forward.

Initially, queue is empty with front=0 and rear=-1.

Enqueue 10, 20, 30 adds them at rear positions 0,1,2.

Dequeue removes 10 and moves front to 1.

Enqueue 40 adds at rear=3.

So queue elements from front=1 to rear=3 are 20, 30, 40.

🧠 Conceptual

intermediate

Queue Full Condition in Array Implementation

In a simple queue implemented using an array of size 5 with front and rear indices, which condition correctly checks if the queue is full?

A rear == size - 1

B front == rear

C front == 0 && rear == size - 1

D front > rear

💡 Hint

Think about where rear points when the array is full.

In a simple queue using array, rear starts at -1 and moves forward with each enqueue.

When rear reaches size-1 (4 for size 5), the array is full.

Other conditions do not correctly represent full queue.

🔧 Debug

advanced

Identify the Bug in Dequeue Function

What error will occur when running this dequeue function on an empty queue?

DSA C

int dequeue(Queue *q) {
    if (q->front == q->rear) {
        return -1; // queue empty
    }
    int val = q->arr[q->front];
    q->front++;
    return val;
}

A Returns garbage value due to wrong empty check

B Infinite loop in main program

C Causes segmentation fault due to invalid access

D Returns -1 correctly when queue is empty

💡 Hint

Check how front and rear are initialized and how empty is detected.

If rear starts at -1 and front at 0, then front == rear is false initially.

So empty check fails and dequeue accesses invalid index.

❓ Predict Output

advanced

Output After Multiple Enqueue and Dequeue

What is the printed queue state after these operations?

DSA C

typedef struct {
    int arr[4];
    int front;
    int rear;
} Queue;

void enqueue(Queue *q, int val) {
    if (q->rear == 3) return;
    q->rear++;
    q->arr[q->rear] = val;
}

int dequeue(Queue *q) {
    if (q->front > q->rear) return -1;
    int val = q->arr[q->front];
    q->front++;
    return val;
}

int main() {
    Queue q = {.front = 0, .rear = -1};
    enqueue(&q, 5);
    enqueue(&q, 10);
    enqueue(&q, 15);
    dequeue(&q);
    dequeue(&q);
    enqueue(&q, 20);
    enqueue(&q, 25);
    // Print queue
    for (int i = q.front; i <= q.rear; i++) {
        printf("%d -> ", q.arr[i]);
    }
    printf("null\n");
    return 0;
}

A 5 -> 10 -> 15 -> 20 -> 25 -> null

B 20 -> 25 -> null

C 15 -> 20 -> null

D 10 -> 15 -> 20 -> null

💡 Hint

Track front and rear indices carefully after each operation.

Enqueue 5,10,15 fills positions 0,1,2.

Dequeue twice moves front from 0 to 2, removing 5 and 10.

Enqueue 20,25 adds at rear 3 and 4 but array size is 4, so last enqueue ignored.

Queue elements from front=2 to rear=3 are 15 and 20.

But rear max is 3, so 25 enqueue ignored.

🧠 Conceptual

expert

Limitation of Simple Array Queue and Its Solution

Why does a simple queue implemented with a fixed-size array and front/rear indices eventually fail to enqueue new elements even if some elements are dequeued? What is a common solution?

A Because dequeue operation deletes elements physically shifting array; solution is to use linked list instead.

B Because front and rear indices get reset to zero after each dequeue; solution is to increase array size dynamically.

C Because enqueue operation overwrites front elements; solution is to use two arrays.

D Because rear only moves forward and never wraps, the array space at front is wasted; solution is to use a circular queue.

💡 Hint

Think about how front and rear indices move and how array space is reused.

In simple array queue, rear moves forward and never wraps around.

After some dequeues, front moves forward but rear stays at end, so no space to enqueue.

Circular queue wraps rear to start to reuse space.