C Program To Implement a Queue

The following program demonstrates how we can implement a Queue in C:

C
// C Program to demonstrate how to Implement a queue
#include <stdbool.h>
#include <stdio.h>
#define MAX_SIZE 100

// Defining the Queue structure
typedef struct {
    int items[MAX_SIZE];
    int front;
    int rear;
} Queue;

// Function to initialize the queue
void initializeQueue(Queue* q)
{
    q->front = -1;
    q->rear = 0;
}

// Function to check if the queue is empty
bool isEmpty(Queue* q) { return (q->front == q->rear - 1); }

// Function to check if the queue is full
bool isFull(Queue* q) { return (q->rear == MAX_SIZE); }

// Function to add an element to the queue (Enqueue
// operation)
void enqueue(Queue* q, int value)
{
    if (isFull(q)) {
        printf("Queue is full\n");
        return;
    }
    q->items[q->rear] = value;
    q->rear++;
}

// Function to remove an element from the queue (Dequeue
// operation)
void dequeue(Queue* q)
{
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }
    q->front++;
}

// Function to get the element at the front of the queue
// (Peek operation)
int peek(Queue* q)
{
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return -1; // return some default value or handle
                   // error differently
    }
    return q->items[q->front + 1];
}

// Function to print the current queue
void printQueue(Queue* q)
{
    if (isEmpty(q)) {
        printf("Queue is empty\n");
        return;
    }

    printf("Current Queue: ");
    for (int i = q->front + 1; i < q->rear; i++) {
        printf("%d ", q->items[i]);
    }
    printf("\n");
}

int main()
{
    Queue q;
    initializeQueue(&q);

    // Enqueue elements
    enqueue(&q, 10);
    printQueue(&q);

    enqueue(&q, 20);
    printQueue(&q);

    enqueue(&q, 30);
    printQueue(&q);

    // Peek front element
    printf("Front element: %d\n", peek(&q));

    // Dequeue an element
    dequeue(&q);
    printQueue(&q);

    // Peek front element after dequeue
    printf("Front element after dequeue: %d\n", peek(&q));

    return 0;
}

Output
Current Queue: 10 
Current Queue: 10 20 
Current Queue: 10 20 30 
Front element: 10
Current Queue: 20 30 
Front element after dequeue: 20

Problem with Above Implementation

The queue above works fine only for single usage. For example, lets fill the queue completely and then dequeue all the elements. Then, the front = rear – 1, which is the condition for the full queue even though the queue is empty. To resolve this, we implement the circular increment (or modular increment) for the index pointers. This kind of queue is called Circular Queue.

To know more, refer to the article – Introduction to the Circular Queue

Queue in C

A queue is a linear data structure that follows the First In First Out (FIFO) order of insertion and deletion. It means that the element that is inserted first will be the first one to be removed and the element that is inserted last will be removed at last.

In this article, we’ll learn how to implement the queue data structure in the C programming language. We will also look at some of its basic operations along with their time and space complexity analysis.

Similar Reads

Implementation of a Queue in C

We can implement a queue in C using either an array or a linked list. In this article, we will use the array data structure to store the elements. The insertion in the queue is done at the back of the queue and the deletion is done at the front. So we maintain two index pointers front and rear pointers to keep track of the front and back of the queue. The queue consists of two basic operations enqueue which adds elements to the queue (insertion) from the rear pointer and dequeue(deletion) which removes elements from the queue through the front pointer....

Basic Operations of Queue in C

Following are the basic operations of a Queue that are used frequently to manipulate the elements present inside the queue:...

C Program To Implement a Queue

The following program demonstrates how we can implement a Queue in C:...

Applications of Queue

Following are some common applications of the queue data structure:...

Limitations of Queue

Following are the major limitation of the queue:...

Conclusion

In C, there is no build in data structure so knowing how to implement queue not only improves our efficiency in the language but also helps us to understand the queue data structure from the base. This article covered the basic implementation of the queue along with its basic operations and also discussed is limitations and referred the article with the solution to that limitation....