Queue using array

An array-based queue stores elements in contiguous memory and tracks two indices: front (next to remove) and rear (last inserted). The best practical fixed-size design is the circular queue, where indices wrap with modulo and both enqueue and dequeue are O(1).

1) Array representation

To avoid costly shifts, use circular indexing instead of moving all elements after every dequeue.

2) Mapping operations

3) Example in C

#include <stdio.h>
#include <stdlib.h>

#define MAX 5  // Maximum size of the queue

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

// Function to check if the queue is full
int isFull() {
    return rear == MAX - 1;
}

// Function to check if the queue is empty
int isEmpty() {
    return front == -1 || front > rear;
}

// Function to add an element to the queue (Enqueue)
void enqueue(int value) {
    if (isFull()) {
        printf("Queue Overflow! Cannot insert %d\n", value);
        return;
    }

    if (front == -1) {
        front = 0;  // Set front to 0 when inserting first element
    }

    rear++;
    queue[rear] = value;
    printf("Enqueued: %d\n", value);
}

// Function to remove an element from the queue (Dequeue)
void dequeue() {
    if (isEmpty()) {
        printf("Queue Underflow! Queue is empty\n");
        return;
    }

    printf("Dequeued: %d\n", queue[front]);
    front++;

    // Reset queue if it becomes empty
    if (front > rear) {
        front = -1;
        rear = -1;
    }
}

// Function to get the front element without removing it
int peek() {
    if (isEmpty()) {
        printf("Queue is empty\n");
        return -1;
    }
    return queue[front];
}

// Function to display all elements in the queue
void display() {
    if (isEmpty()) {
        printf("Queue is empty\n");
        return;
    }

    printf("Queue elements: ");
    for (int i = front; i <= rear; i++) {
        printf("%d ", queue[i]);
    }
    printf("\n");
}

// Main function to test the queue
int main() {
    printf("=== Queue Implementation using Array ===\n");
    printf("Maximum size: %d\n\n", MAX);

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

    display();

    printf("\nFront element: %d\n", peek());

    dequeue();
    dequeue();

    display();

    enqueue(60);  // This will show overflow (queue is full)

    printf("\nFront element after dequeue: %d\n", peek());

    return 0;
}

Execution Flow with Output Table

Queue State Visualization Table

Note: strikethrough indicates deleted/ignored positions (wasted space).

Key Observations Table

Limitation Summary Table

4) Trade-offs

• Pros — Simple, cache-friendly, O(1) operations with circular indexing.
• Cons — Fixed capacity unless resized manually.

Compare with Queue using linked list for dynamic growth, and Circular queue for deeper wrap-around discussion.