Queue Implementation Using Array

Key Highlights 

• Queue implementation using array is a linear data structure approach where elements are stored in a fixed-size array, following the First In, First Out (FIFO) principle. 
• The implementation relies on two pointers, front and rear, to manage insertion (enqueue) and deletion (dequeue) operations efficiently within the array. 
• In a simple linear queue, deleted positions cannot be reused once the rear reaches the end of the array, leading to false overflow, which is why circular queues are often preferred for better space utilization. 
• This blog  explains queue implementation using array with algorithms, operations, code examples, along with advantages, limitations, and practical examples suitable for beginners.

Take your programming and data skills to the next level with upGrad's Data Science programs. Learn Python, data structures, machine learning, and AI through hands-on projects, expert mentorship, and career support.

What Is Queue Implementation Using Array?

A queue stores elements in the order they arrive. The first element inserted into the queue is also the first one removed. That's why queues follow the FIFO (First In, First Out) rule.

In queue implementation using array, all queue elements are stored inside a fixed-size array. Two variables keep track of the queue.

• Front
• Rear

The front points to the first element available for deletion.

The rear points to the most recently inserted element.

This style of implementation of queue using array is widely used when the maximum number of elements is known in advance. Since arrays provide direct memory access, insertion and deletion checks are straightforward and easy to implement.

Imagine a queue with a capacity of five elements.

Index	0	1	2	3	4
Value	12	18	25	Empty	Empty

Here,

• Front = 0
• Rear = 2

If another value is inserted, the rear pointer moves one position to the right.

If the first value is removed, the front pointer also moves forward.

This is the basic idea behind queue implementation using array in data structure.

Also read : queue implementation. 

How to  Implement  Queue Using Array 

The implementation of queue using array follows a straightforward approach in which a fixed-size array stores elements, while two pointers (front and rear) keep track of the first and last elements in the queue. Every insertion takes place at the rear, and every deletion occurs from the front, ensuring the queue follows the First In, First Out (FIFO) principle.

To build the implementation of queue using array, you first declare an array, initialize the pointers, and then perform queue operations such as enqueue, dequeue, peek, and status checks for overflow and underflow. Although programming syntax varies across C, C++, Java, and Python, the underlying logic remains the same.

Step 1: Declare the Queue

Create an array with a fixed capacity to store queue elements. The array serves as the queue's storage, where each element occupies a specific index. The maximum size is fixed during declaration, allowing efficient access while limiting the total number of elements the queue can hold.

queue[MAX] 

Step 2: Initialize Front and Rear

Before performing any queue operation, initialize both the front and rear pointers to -1 to indicate that the queue is empty. These pointers track the first and last elements in the queue and are updated whenever elements are inserted or removed.

front = -1

rear = -1

Step 3: Perform Enqueue Operation

Before inserting a new element:

• Check whether the queue is full.
• If the queue is empty, set both front and rear to 0.
• Otherwise, increment rear by one.
• Insert the new element at queue[rear].

Step 4: Perform Dequeue Operation

Before removing an element:

• Check whether the queue is empty.
• Store the element at queue[front].
• If the queue contains only one element, reset both pointers to -1.
• Otherwise, increment front by one.

Step 5: Perform Peek and Rear Operations

• Use the Peek operation to view the front element without removing it.
• Use the Rear operation to retrieve the most recently inserted element.
• Neither operation modifies the queue.

Step 6: Validate Queue Status

Before every insertion or deletion:

• Use IsFull() to avoid queue overflow.
• Use IsEmpty() to prevent queue underflow.

These validation checks ensure that queue operations are performed safely and efficiently.

Simple Queue Implementation Using Array in C

#include <stdio.h> 
 
#define SIZE 5 
 
int queue[SIZE]; 
int front = -1, rear = -1; 
 
void enqueue(int value) { 
   if (rear == SIZE - 1) { 
       printf("Queue Overflow\n"); 
       return; 
   } 
 
   if (front == -1) 
       front = 0; 
 
   queue[++rear] = value; 
} 
 
void dequeue() { 
   if (front == -1 || front > rear) { 
       printf("Queue Underflow\n"); 
       return; 
   } 
 
   printf("Deleted: %d\n", queue[front]); 
   front++; 
 
   if (front > rear) 
       front = rear = -1; 
} 
 
void display() { 
   int i; 
 
   if (front == -1) { 
       printf("Queue is Empty\n"); 
       return; 
   } 
 
   printf("Queue: "); 
 
   for (i = front; i <= rear; i++) 
       printf("%d ", queue[i]); 
 
   printf("\n"); 
} 
 
int main() { 
   enqueue(10); 
   enqueue(20); 
   enqueue(30); 
 
   display(); 
 
   dequeue(); 
 
   display(); 
 
   return 0; 
} 

Output

Queue: 10 20 30 
Deleted: 10 
Queue: 20 30

Also read : guide on dynamic memory n C.

Queue Operations Using Array

Once a queue has been created, it becomes useful only when you can perform operations on it. Every queue implementation using array supports a few core operations that allow you to insert, remove, and inspect elements while maintaining the FIFO principle. 

Each operation has a specific purpose. Together, they make the implementation of queue using array suitable for applications such as task scheduling, printer queues, and buffering systems.

Let's understand each operation.

Peek Operation

The Peek operation returns the element at the front of the queue without removing it.

It's useful when you only need to know which element will be processed next.

Syntax 

REAR (queue)
 IF front == -1 THEN
    PRINT "Queue Underflow"
ELSE
    RETURN queue[rear]
END IF

For example, if the queue contains:

[15] [25] [35] [ ] 
The Peek operation returns 15 because it is the first element in the queue.

Since no insertion or deletion occurs, both the front and rear pointers remain unchanged.

Rear Operation

The Rear operation returns the most recently inserted element.

Syntax

REAR(queue) 
 
IF front == -1 THEN 
   PRINT "Queue Underflow" 
ELSE 
   RETURN queue[rear] 
END IF

Suppose the queue contains:

[15] [25] [35] [45] 
The Rear operation returns 45 because it is stored at the rear of the queue.

Like Peek, this operation doesn't modify the queue.

IsEmpty()

Before removing an element, the program should always verify whether the queue contains any data. 

If both pointers indicate that no elements exist, the queue is considered empty. 

Syntax

ISEMPTY() 
 
IF front == -1 OR front > rear THEN 
   RETURN TRUE 
ELSE 
   RETURN FALSE 
END IF 

This simple check prevents invalid dequeue operations and is a standard part of every queue implementation using array in data structure.

IsFull()

Since an array has a fixed capacity, the program should also check whether all positions are occupied before inserting a new element.If the rear pointer has reached the last available index, the queue is full.

Syntax

ISFULL() 
 
IF rear == MAX - 1 THEN 
   RETURN TRUE 
ELSE 
   RETURN FALSE 
END IF

Attempting another insertion without checking this condition causes a queue overflow.

These validation operations make the implementation queue using array more reliable and easier to debug.

Also read : linked list implementation in C   

Enqueue and Dequeue Operations in Queue Using Array

Enqueue and Dequeue are the two most important operations in a queue. Every other operation supports or validates these two.

Understanding them is the key to mastering queue implementation using array.

Enqueue Operation

The Enqueue operation inserts a new element at the rear of the queue.

Before insertion, the program checks whether the queue has enough space.

If space is available:

• Increment the rear pointer.
• Insert the new element.
• If it's the first insertion, initialize the front pointer.

Suppose the queue is empty.

[ ] [ ] [ ] [ ] [ ] 
 

Insert 10.

[10] [ ] [ ] [ ] [ ] 
Front = 0 
Rear = 0 
 

Insert 20.

[10] [20] [ ] [ ] [ ] 
Front = 0 
Rear = 1 
 

Only the rear pointer moves because new elements are always added at the end.

This behavior remains the same in every implementation of a queue using array, regardless of the programming language.

Dequeue Operation

The Dequeue operation removes the element at the front of the queue.

Unlike Enqueue, it works from the opposite end.

Before removing an element, the program verifies that the queue isn't empty.

Consider this queue.

[10] [20] [30] [40] [ ] 
Front = 0 
Rear = 3 
After one Dequeue operation, 10 is removed.

Logically, the queue becomes:

[ ] [20] [30] [40] [ ] 
Front = 1 
Rear = 3 
The remaining elements don't shift to the left.Instead, only the front pointer moves forward.

This makes deletion efficient and keeps the implementation of queue using array in C simple because unnecessary data movement is avoided.

Step-by-Step Operation Flow

The following example shows how a queue changes after each operation.

 

 

This simple flow clearly shows how insertion and deletion affect the front and rear pointers while preserving the FIFO order.

Also read : stack implementation using linked lists 

Queue Implementation Using Array Example

Now let's put everything together with a simple example. Assume an array with a capacity of five elements.

Initially, the queue is empty.

Front	Rear	Queue
-1	-1	[ ] [ ] [ ] [ ] [ ]

Initial Queue State

Insert 5.

Front	Rear	Queue
0	0	[5] [ ] [ ] [ ] [ ]

Next, insert 15 and 25.

Front	Rear	Queue
0	2	[5] [15] [25] [ ] [ ]

The queue now contains three elements in the order they were inserted.

Performing Dequeue

Remove one element.

Front	Rear	Queue
1	2	[ ] [15] [25] [ ] [ ]

The value 5 is removed because it entered the queue first.

The remaining elements stay in their original positions, while only the front pointer changes.

Final Queue State

Insert 35.

Front	Rear	Queue
1	3	[ ] [15] [25] [35] [ ]

The following program combines all the steps discussed above into a single example. It performs enqueue and dequeue operations in sequence, allowing you to observe how the front and rear pointers change as the queue is updated.

#include <stdio.h>
 #define SIZE 5
 
// Queue structure 
struct Queue { 
    int items[SIZE]; 
    int front; 
    int rear; 
}; 
  
// Initialize queue 
void initialize(struct Queue *q) { 
    q->front = -1; 
    q->rear = -1; 
} 
  
// Enqueue operation 
void enqueue(struct Queue *q, int value) { 
    if (q->rear == SIZE - 1) { 
        printf("Queue Overflow\n"); 
        return; 
    } 
  
    if (q->front == -1) 
        q->front = 0; 
  
    q->items[++q->rear] = value; 
} 
  
// Dequeue operation 
void dequeue(struct Queue *q) { 
    if (q->front == -1 || q->front > q->rear) { 
        printf("Queue Underflow\n"); 
        return; 
    } 
  
    printf("Dequeued Element: %d\n", q->items[q->front]); 
    q->front++; 
  
    if (q->front > q->rear) { 
        q->front = -1; 
        q->rear = -1; 
    } 
} 
  
// Display queue 
void display(struct Queue *q) { 
    int i; 
  
    if (q->front == -1) { 
        printf("Queue is Empty\n"); 
        return; 
    } 
  
    printf("Queue: "); 
  
    for (i = q->front; i <= q->rear; i++) 
        printf("%d ", q->items[i]); 
  
    printf("\n"); 
} 
  
int main() { 
    struct Queue q; 
  
    initialize(&q); 
  
    // Insert 5, 15, and 25 
    enqueue(&q, 5); 
    enqueue(&q, 15); 
    enqueue(&q, 25); 
  
    display(&q); 
  
    // Remove one element 
    dequeue(&q); 
  
    display(&q); 
  
    // Insert 35 
    enqueue(&q, 35); 
  
    display(&q); 
  
    return 0; 
} 

Output

Queue: 5 15 25 
Dequeued Element: 5 
Queue: 15 25 
Queue: 15 25 35

This example demonstrates the complete working of the queue implementation using array in data structures . Although the queue appears simple, every insertion and deletion follows the same FIFO rule. Once you understand these operations, implementing the data structure in code becomes much easier.

 

Ready to move beyond programming fundamentals? upGrad's Executive Diploma in Data Science & Artificial Intelligence from IIITB equips you with practical expertise in Python, data science, machine learning, and artificial intelligence through an industry-focused curriculum and project-based learning.

 

Front and Rear Pointers in Queue Using Array

The front and rear pointers are the backbone of queue implementation using array. Without them, the program wouldn't know where to insert a new element or which element should be removed next.

Think of these pointers as markers rather than data. They don't store queue elements. Instead, they keep track of the queue's current boundaries inside the array.

Once you understand how these pointers move, the implementation of queue using array becomes much easier to visualize and debug.

What Is the Front Pointer?

The front pointer always points to the first valid element in the queue.

Whenever a dequeue operation is performed, the front pointer moves one position ahead.

For example, consider the following queue.

Queue	Front	Rear
[10] [20] [30] [ ] [ ]	0	2

After removing 10, the queue logically becomes:

Queue	Front	Rear
[ ] [20] [30] [ ] [ ]	1	2

Notice that only the front pointer changes. The remaining elements stay where they are.

This approach avoids unnecessary shifting of data and keeps queue operations efficient.

What Is the Rear Pointer?

The rear pointer always identifies the last inserted element.

Whenever a new value is added, the rear pointer moves to the next available position.

Example:

Operation	Queue	Rear
Enqueue 10	[10] [ ] [ ] [ ] [ ]	0
Enqueue 20	[10] [20] [ ] [ ] [ ]	1
Enqueue 30	[10] [20] [30] [ ] [ ]	2

The rear pointer grows with every insertion, while the front pointer remains unchanged until a deletion occurs.

This pointer movement is identical in every implementation of queue using array in C and other programming languages.

Also read : Difference between LinkedList and Array in Java

How Front and Rear Move During Queue Operations

The movement of both pointers follows a simple pattern.

Operation	Front	Rear
Initialize	-1	-1
First Enqueue	0	0
Next Enqueue	0	1
Another Enqueue	0	2
Dequeue	1	2
Next Dequeue	2	2

Only one pointer changes during each operation.

• Enqueue updates the rear pointer.
• Dequeue updates the front pointer.

This predictable behavior makes queue implementation using array in data structure easier to understand and implement.

Common Pointer Errors

Pointer-related mistakes are common, especially when you're implementing a queue for the first time.

Some of the most frequent errors include:

• Updating the front pointer during insertion.
• Updating the rear pointer during deletion.
• Forgetting to initialize both pointers after the first insertion.
• Failing to reset the pointers when the queue becomes empty.

Testing these edge cases helps you build a more reliable queue implementation.

Linear Queue Implementation Using Array

A linear queue is the simplest form of queue implementation using array. Elements are inserted from the rear and removed from the front. Once the rear pointer reaches the last index of the array, no more elements can be inserted.

It looks simple. Yet it has one important drawback.

How a Linear Queue Works

Consider an array with five positions.

Step	Queue	Front	Rear
Initial	[ ] [ ] [ ] [ ] [ ]	-1	-1
Enqueue 10	[10] [ ] [ ] [ ] [ ]	0	0
Enqueue 20	[10] [20] [ ] [ ] [ ]	0	1
Enqueue 30	[10] [20] [30] [ ] [ ]	0	2

The queue continues to grow until the last index is reached.

Advantages of a Linear Queue

• Easy to understand.
• Simple to implement.
• Suitable for fixed-size applications.
• Requires minimal logic.

These benefits make the implementation queue using array an excellent learning exercise for beginners.

Limitation of a Linear Queue

Now consider this sequence.

1. Insert five elements.
2. Remove three elements.

The queue becomes:

Queue	Front	Rear
[ ] [ ] [ ] [40] [50]	3	4

Although the first three positions are empty, new elements can't be inserted because the rear pointer has already reached the last index. 

This unused space is called memory wastage.

It's the biggest drawback of a linear queue and the main reason circular queues were introduced.

Circular Queue Implementation Using Array

A circular queue solves the unused space problem found in a linear queue.

Instead of stopping at the last array position, the rear pointer wraps around to the beginning whenever free space becomes available.

This small improvement makes a big difference.

Why Is a Circular Queue Needed?

A standard queue implemented using an array cannot reuse the empty spaces created after dequeue operations. As a result, the queue may appear full even when unused positions are available. The following example illustrates why a circular queue is needed to solve this limitation.

Queue	Front	Rear
[ ] [ ] [30] [40] [50]	2	4

The first two positions are empty. A linear queue can't use them.

A circular queue can. The rear pointer simply returns to index 0 and starts inserting elements again.

How a Circular Queue Works

The queue behaves like a circle instead of a straight line.

Pointer movement follows this pattern:

0 → 1 → 2 → 3 → 4 
↑                 ↓ 
└─────────────────┘ 
Whenever the rear reaches the last index, it checks whether free space exists at the beginning.

If it does, insertion continues from there.

This makes much better use of available memory.

Linear Queue vs Circular Queue

Both linear and circular queues follow the FIFO principle, but they differ in how they utilize available memory. The comparison below highlights their key differences in structure, efficiency, and space utilization.

Feature	Linear Queue	Circular Queue
Memory usage	Wastes space	Efficient
Pointer movement	One direction	Circular
Overflow	Occurs sooner	Delayed until queue is actually full
Implementation	Simple	Slightly more complex

If your application performs frequent enqueue and dequeue operations, a circular queue is usually the better choice.

Queue overflow in array implementation

Two common errors can occur during queue implementation using array.

They are overflow and underflow. Understanding these conditions helps prevent runtime errors and unexpected behavior.

Queue Overflow

Overflow occurs when an insertion is attempted after the queue becomes full.

Example:

Capacity = 5

Current Queue:

[10] [20] [30] [40] [50] 
Trying to insert another element isn't possible because every position is already occupied.

The program should detect this condition before performing the insertion.

How to Prevent These Errors

Follow these simple practices.

• Check IsFull() before every enqueue operation.
• Check IsEmpty() before every dequeue operation.
• Update the front and rear pointers correctly.
• Test boundary conditions during implementation.

These checks make the implementation of queue using array more reliable and easier to maintain.

Also read : Implementation of Queue Using Linked List in C with Code Example

Queue Implementation Using Array vs Linked List

Choosing between an array and a linked list depends on how your application stores and manages data. Both follow the FIFO principle, but they differ in memory allocation, flexibility, and performance.

If you're learning queue implementation using array, it's useful to understand where arrays perform well and where linked lists have an advantage.

Comparison Between Queue Using Array and Queue Using Linked List : 

Feature	Queue Using Array	Queue Using Linked List
Memory allocation	Fixed size	Dynamic size
Memory usage	May waste unused space	Uses memory only when needed
Overflow	Possible when array is full	Limited only by available memory
Cache performance	Better due to contiguous memory	Slightly slower because nodes are scattered
Implementation	Easier for beginners	More complex
Best suited for	Fixed-size applications	Frequently changing queue sizes

When Should You Choose an Array-Based Queue?

An array-based queue is a good choice when:

• The maximum queue size is known beforehand.
• Fast index-based access is preferred.
• Memory allocation should remain simple.
• The application doesn't require frequent resizing.

Examples include printer queues, keyboard buffers, and embedded systems where memory usage is predefined.

When Is a Linked List a Better Choice?

A linked-list queue is more suitable when:

• The queue size changes frequently.
• Memory should grow dynamically.
• Overflow caused by fixed capacity must be avoided.
• Large datasets are processed continuously.

Although linked lists offer greater flexibility, the implementation of queue using array is still preferred in many learning environments because it's easier to understand and implement.

Also read : Stack Implementation Using Array in Data Structures 

Advantages and Limitations of Queue Implementation Using an Array

Like every data structure, queue implementation using array has strengths and limitations. Knowing both helps you decide whether it's the right choice for your application.

Advantages

The implementation of queue using array offers several benefits.

• Easy to understand and implement.
• Fast insertion and deletion operations.
• Better cache performance because elements are stored in contiguous memory.
• Requires fewer memory allocations than linked lists.
• Suitable for applications with a fixed queue size.

These advantages make the implementation queue using array one of the first queue implementations taught in data structure courses.

Limitations

Despite its simplicity, an array-based queue has a few drawbacks.

• The queue size is fixed.
• Overflow occurs once the array becomes full.
• Memory can be wasted in a linear queue after several dequeue operations.
• Increasing the queue size requires creating a new array.

For applications with unpredictable workloads, a linked-list queue or a circular queue is often a better alternative.

Also read : Types of Queue 

BestPractices for Implementing a Queue Using Array

Writing a queue isn't only about making it work. Good implementations are easier to understand, maintain, and debug.

Keep these best practices in mind.

• Initialize the front and rear pointers correctly.
• Check IsFull() before every enqueue operation.
• Check IsEmpty() before every dequeue operation.
• Use descriptive variable names such as front, rear, and capacity.
• Test edge cases like an empty queue, a full queue, and a queue with a single element.
• Prefer a circular queue when frequent insertions and deletions are expected.

These practices make the implementation of queue using array in C cleaner and reduce common programming mistakes.

Also read: Doubly Linked List Data Structures: A Complete Guide 

Conclusion

Learning queue implementation using array gives you a strong foundation for understanding queues and other linear data structures. By using an array along with front and rear pointers, you can efficiently insert and remove elements while maintaining the FIFO order.

Although a simple array-based queue has limitations such as fixed capacity and memory wastage in linear queues, it's still one of the easiest ways to understand queue operations. Once you're comfortable with this approach, you'll find it much easier to explore circular queues, linked-list implementations, and more advanced data structures.

Ready to start your journey? Book a free consultation with upGrad today to find the best path for your career.