Queue Implementation Using Array in DSA C - Build from Scratch

Queue Implementation Using Array

📖 Scenario: Imagine you are managing a line of customers waiting to buy tickets at a counter. You want to keep track of who is next in line using a queue. A queue works like a real line: the first person to get in line is the first person to be served.

🎯 Goal: You will build a simple queue using an array in C. You will add customers to the queue, remove them when they are served, and see the current state of the queue.

📋 What You'll Learn

Create an array to hold the queue elements

Use variables to track the front and rear positions in the queue

Implement enqueue operation to add elements to the queue

Implement dequeue operation to remove elements from the queue

Print the queue elements after operations

💡 Why This Matters

🌍 Real World

Queues are used in real life to manage lines, like customers waiting for service, print jobs waiting to print, or tasks waiting to be processed.

💼 Career

Understanding queue implementation helps in software development roles where managing ordered tasks or requests efficiently is important, such as in operating systems, web servers, and real-time systems.

1

Create the queue array and initialize front and rear

Create an integer array called queue with size 5. Create two integer variables called front and rear. Set front to -1 and rear to -1.

DSA C

# Create the queue array and initialize front and rear
// Your code here

Hint

Use int queue[5]; to create the array. Set front and rear to -1 to show the queue is empty.

2

Add two customers to the queue using enqueue logic

Add code to enqueue two customers with values 10 and 20 into the queue. Update front and rear accordingly. Use the logic: if front is -1, set it to 0. Then increase rear by 1 and add the value at queue[rear].

DSA C

int queue[5];
int front = -1;
int rear = -1;

// Enqueue 10 and 20 into the queue
// Your code here

Hint

Remember to set front to 0 only once when the first element is added. Then increase rear and add the value.

3

Remove one customer from the queue using dequeue logic

Add code to dequeue one customer from the queue. Increase front by 1 to remove the front element. If after removal front becomes greater than rear, reset both front and rear to -1 to show the queue is empty.

DSA C

int queue[5];
int front = -1;
int rear = -1;

// Enqueue 10
if (front == -1) {
    front = 0;
}
rear++;
queue[rear] = 10;

// Enqueue 20
rear++;
queue[rear] = 20;

// Dequeue one element
// Your code here

Hint

To remove the front element, increase front. If the queue becomes empty, reset both front and rear to -1.

4

Print the current queue elements

Write a for loop to print all elements in queue from front to rear. Print each element followed by a space. If the queue is empty (when front is -1), print Queue is empty.

DSA C

int queue[5];
int front = -1;
int rear = -1;

// Enqueue 10
if (front == -1) {
    front = 0;
}
rear++;
queue[rear] = 10;

// Enqueue 20
rear++;
queue[rear] = 20;

// Dequeue one element
front++;
if (front > rear) {
    front = -1;
    rear = -1;
}

// Print the queue elements
// Your code here

Hint

Use a for loop from front to rear to print elements. If empty, print Queue is empty.

Practice

1. What is the main characteristic of a queue implemented using an array?

easy

A. It follows First-In-First-Out (FIFO) order

B. It follows Last-In-First-Out (LIFO) order

C. It allows random access to elements

D. It stores elements in sorted order

Solution

1. Step 1: Understand queue behavior

   A queue is a data structure where the first element added is the first one to be removed, which is FIFO.

2. Step 2: Compare with options

   It follows First-In-First-Out (FIFO) order correctly states FIFO order. It follows Last-In-First-Out (LIFO) order is LIFO (stack), C allows random access (array), D stores sorted (not queue).

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option A

4. Quick Check:

   Queue = FIFO [OK]

Hint: Queue always removes the oldest element first [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements automatically

2. Which of the following is the correct way to declare a queue array of size 5 in C?

easy

A. queue int[5];

B. int queue[5];

C. int queue();

D. int queue = new int[5];

Solution

1. Step 1: Recall C array declaration syntax

   In C, arrays are declared as type name[size], e.g., int queue[5];

2. Step 2: Check each option

   int queue[5]; matches correct syntax. queue int[5]; is invalid syntax. int queue(); declares a function, not an array. int queue = new int[5]; is Java-style syntax.

3. Final Answer:

   int queue[5]; -> Option B

4. Quick Check:

   C array declaration = int name[size] [OK]

Hint: C arrays use type name[size] syntax [OK]

Common Mistakes:

• Using Java or other language syntax
• Confusing function declaration with array
• Missing semicolon or brackets

3. Consider this C code snippet for a queue implemented using an array of size 3:

int queue[3];
int front = -1, rear = -1;

// Enqueue 10
rear++;
queue[rear] = 10;
if(front == -1) front = 0;

// Enqueue 20
rear++;
queue[rear] = 20;

// Dequeue
int val = queue[front];
front++;

// Enqueue 30
rear++;
queue[rear] = 30;

// Current queue elements from front to rear?

medium

A. 30 -> null

B. 10 -> 20 -> 30 -> null

C. 20 -> 30 -> null

D. 10 -> 30 -> null

Solution

1. Step 1: Trace enqueue and dequeue operations

   Initially front = -1, rear = -1. Enqueue 10: rear=0, queue[0]=10, front=0. Enqueue 20: rear=1, queue[1]=20. Dequeue: val=queue[front]=queue[0]=10, front=1. Enqueue 30: rear=2, queue[2]=30.

2. Step 2: Identify current queue elements

   front=1, rear=2, so elements are queue[1]=20 and queue[2]=30. Hence queue is 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option C

4. Quick Check:

   After dequeue, front moves forward; queue = 20, 30 [OK]

Hint: After dequeue, front moves forward; queue shows elements from front to rear [OK]

Common Mistakes:

• Not updating front after dequeue
• Including dequeued elements in output
• Confusing front and rear indices

4. Identify the error in this queue enqueue function using array in C:

void enqueue(int queue[], int *rear, int size, int value) {
    if (*rear == size) {
        printf("Queue is full\n");
        return;
    }
    (*rear)++;
    queue[*rear] = value;
}

medium

A. rear should be compared with size - 1, not size

B. rear should be incremented after inserting value

C. Function should return int instead of void

D. queue array should be dynamically allocated

Solution

1. Step 1: Analyze the full condition

   The check if(*rear == size) is wrong. Array indices are 0 to size-1, so full when *rear == size-1 before incrementing. Current check allows overflow.

2. Step 2: Compare options

   rear should be compared with size - 1, not size identifies the correct fix: compare with size-1, not size. Others are incorrect.

3. Final Answer:

   rear should be compared with size - 1, not size -> Option A

4. Quick Check:

   Full: *rear == size-1 [OK]

Hint: Full check: rear == size - 1 [OK]

Common Mistakes:

• Comparing rear == size instead of size-1
• Incorrect overflow condition
• Ignoring zero-based indexing

5. You have a queue implemented using an array of size 4 with front = 1 and rear = 3. After dequeuing two elements and enqueuing one element, what will be the correct front and rear values if you implement a circular queue?

hard

A. front = 2, rear = 0

B. front = 3, rear = 1

C. front = 0, rear = 1

D. front = 3, rear = 0

Solution

1. Step 1: Understand initial state and operations

   Initial: front=1, rear=3, size=4. Dequeue twice: front moves forward twice. Since circular, front = (1 + 2) % 4 = 3.

2. Step 2: Enqueue one element

   rear moves forward by one circularly: rear = (3 + 1) % 4 = 0.

3. Final Answer:

   front = 3, rear = 0 -> Option D

4. Quick Check:

   Circular queue uses modulo for front and rear [OK]

Hint: Use modulo to wrap front and rear in circular queue [OK]

Common Mistakes:

• Not using modulo for circular increment
• Updating front or rear incorrectly
• Confusing front and rear positions