Queue Implementation Using Array in DSA Java - Build from Scratch

Queue Implementation Using Array

📖 Scenario: Imagine you are managing a line of customers waiting to buy tickets at a movie theater. You want to keep track of who is next in line and who has already been served. This is a perfect example of a queue, where the first person to get in line is the first to be served.

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

📋 What You'll Learn

Create an array-based queue with fixed size

Implement enqueue operation to add elements

Implement dequeue operation to remove elements

Display the queue elements in order

💡 Why This Matters

🌍 Real World

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

💼 Career

Understanding queues is important for software developers working on scheduling, resource management, and real-time systems.

1

Create the queue array and variables

Create an integer array called queue with size 5. Also create two integer variables called front and rear and set both to -1.

DSA Java

int[] queue = new int[5];
int front = -1;
int rear = -1;
// Your code here

Hint

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

2

Add an element to the queue (enqueue)

Add code inside main to enqueue the number 10 into the queue. Update rear by increasing it by 1, and if front is -1, set it to 0. Then assign 10 to queue[rear].

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = -1;
        int rear = -1;
        // Add enqueue code here
    }
}

Hint

Increase rear by 1. If front is -1, set it to 0. Then put 10 at queue[rear].

3

Remove an element from the queue (dequeue)

Add code inside main to dequeue an element from the queue. Store the element at queue[front] in a variable called removed. Then increase front by 1. If front becomes greater than rear, reset both front and rear to -1.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = -1;
        int rear = -1;

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

        // Add dequeue code here
    }
}

Hint

Save queue[front] in removed. Increase front by 1. If front is greater than rear, reset both to -1.

4

Print the current queue elements

Add code inside main to print all elements in the queue from front to rear separated by spaces on one line. Use a for loop with variable i to iterate from front to rear. Print each queue[i] followed by a space.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] queue = new int[5];
        int front = -1;
        int rear = -1;

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

        int removed = queue[front];
        front = front + 1;
        if (front > rear) {
            front = -1;
            rear = -1;
        }

        // Print queue elements here
    }
}

Hint

If front is -1, print "Queue is empty". Otherwise, loop from front to rear and print each element with a space.

Practice

1. What is the main purpose of using an array in a queue implementation?

easy

A. To store elements in a fixed-size linear order

B. To allow random access to elements anywhere in the queue

C. To sort elements automatically when inserted

D. To store elements in a tree structure

Solution

1. Step 1: Understand queue storage

   A queue stores elements in order, so an array can hold them in a fixed linear sequence.

2. Step 2: Compare other options

   Random access and sorting are not queue properties; tree structure is unrelated.

3. Final Answer:

   To store elements in a fixed-size linear order -> Option A

4. Quick Check:

   Queue uses array for linear storage [OK]

Hint: Queue uses array for fixed linear storage [OK]

Common Mistakes:

• Thinking queue allows random access
• Assuming array sorts elements automatically
• Confusing queue with tree structures

2. Which of the following is the correct way to check if a queue implemented using an array is empty?

easy

A. if (front == rear) return true;

B. if (rear == size) return true;

C. if (front == -1) return true;

D. if (front > rear) return true;

Solution

1. Step 1: Understand empty queue condition

   In array queue, front = -1 means no elements have been enqueued yet.

2. Step 2: Analyze other conditions

   front == rear means queue is full or empty depending on implementation; rear == size means full; front > rear is invalid.

3. Final Answer:

   if (front == -1) return true; -> Option C

4. Quick Check:

   Empty queue check uses front == -1 [OK]

Hint: Empty queue usually has front at -1 [OK]

Common Mistakes:

• Using front == rear to check empty (can be full)
• Checking rear == size for empty instead of full
• Using front > rear which is invalid

3. What will be the output after the following operations on a queue of size 5 implemented using an array?

enqueue(10); enqueue(20); dequeue(); enqueue(30); enqueue(40); dequeue(); enqueue(50); display();

medium

A. 30 -> 40 -> 50 -> null

B. 20 -> 30 -> 40 -> 50 -> null

C. 10 -> 20 -> 30 -> 40 -> 50 -> null

D. 40 -> 50 -> null

Solution

1. Step 1: Trace enqueue and dequeue operations

   enqueue(10), enqueue(20) adds 10,20; dequeue removes 10; enqueue(30), enqueue(40) adds 30,40; dequeue removes 20; enqueue(50) adds 50.

2. Step 2: Determine queue content after operations

   Remaining elements are 30, 40, 50 in order.

3. Final Answer:

   30 -> 40 -> 50 -> null -> Option A

4. Quick Check:

   Queue after operations = 30,40,50 [OK]

Hint: Track enqueue/dequeue stepwise to find queue content [OK]

Common Mistakes:

• Not removing correct elements on dequeue
• Assuming queue resets after full
• Confusing order of elements after operations

4. Identify the error in this queue implementation snippet using an array:

if (rear == size) {
  System.out.println("Queue is full");
} else {
  rear++;
  queue[rear] = value;
}

medium

A. rear should be incremented after assigning value

B. queue array size is not checked before insertion

C. front pointer is not updated when queue is empty

D. Condition should be rear == size - 1 to check full

Solution

1. Step 1: Analyze full queue condition

   Array index goes from 0 to size-1, so rear == size means out of bounds; full condition is rear == size - 1.

2. Step 2: Check rear increment and assignment

   Incrementing rear before assignment is correct if rear starts at -1.

3. Final Answer:

   Condition should be rear == size - 1 to check full -> Option D

4. Quick Check:

   Full queue check uses rear == size - 1 [OK]

Hint: Array index max is size - 1, not size [OK]

Common Mistakes:

• Checking rear == size instead of size - 1
• Incrementing rear after assignment causing overwrite
• Ignoring front pointer update on empty queue

5. Given a queue implemented using an array of size 4, initially empty, what will be the state of the queue after these operations?

enqueue(5); enqueue(10); dequeue(); enqueue(15); enqueue(20); enqueue(25); dequeue(); enqueue(30); display();

Assume the queue does not support circular wrapping and front and rear start at -1.

hard

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

B. Queue Overflow error occurs

C. 20 -> 25 -> 30 -> null

D. 15 -> 20 -> 25 -> null

Solution

1. Step 1: Trace each operation stepwise

   enqueue(5) adds 5; enqueue(10) adds 10; dequeue removes 5; enqueue(15) adds 15; enqueue(20) adds 20; enqueue(25) attempts to add but queue size is 4 and rear is at last index.

2. Step 2: Check for overflow due to no circular wrap

   Since queue is full at rear index 3, enqueue(25) causes overflow; subsequent operations cannot proceed.

3. Final Answer:

   Queue Overflow error occurs -> Option B

4. Quick Check:

   No circular wrap causes overflow at full array [OK]

Hint: Without circular queue, overflow occurs when rear reaches end [OK]

Common Mistakes:

• Assuming queue wraps around without circular logic
• Ignoring overflow condition on enqueue
• Miscounting elements after dequeue