📌 Circular Queue: Creation, Addition, Deletion, Full & Empty Conditions

A Circular Queue is an improved version of a simple queue, where the last position is connected to the first to form a circle. This avoids wastage of space seen in normal queue implementations.

---

1️⃣ Why Use a Circular Queue?

🔹 Efficient Memory Utilization – Unlike linear queues, no space is wasted after deletions.
🔹 Circular Connections – The rear can wrap around to the front when space is available.
🔹 Used in Operating Systems, CPU Scheduling, Buffer Management.

---

2️⃣ Basic Operations on Circular Queue

Operation	Description
Create	Initializes an empty queue.
Enqueue (Add)	Inserts an element at the rear.
Dequeue (Delete)	Removes an element from the front.
isFull()	Checks if the queue is full.
isEmpty()	Checks if the queue is empty.
Front() / Peek()	Returns the front element without removing it.

---

3️⃣ Circular Queue Implementation in C

(a) Using Arrays

#include <stdio.h>
#define SIZE 5  // Define maximum size of queue

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

// Check if the queue is empty
int isEmpty() {
    return (front == -1);
}

// Check if the queue is full
int isFull() {
    return ((rear + 1) % SIZE == front);
}

// Insert an element in Circular Queue
void enqueue(int value) {
    if (isFull()) {
        printf("Queue is Full!\n");
        return;
    }
    if (front == -1) front = 0;  // Initialize front if queue was empty
    rear = (rear + 1) % SIZE;
    queue[rear] = value;
    printf("Enqueued: %d\n", value);
}

// Remove an element from Circular Queue
void dequeue() {
    if (isEmpty()) {
        printf("Queue is Empty!\n");
        return;
    }
    printf("Dequeued: %d\n", queue[front]);
    if (front == rear) front = rear = -1;  // Reset when queue becomes empty
    else front = (front + 1) % SIZE;
}

// Display Circular Queue
void display() {
    if (isEmpty()) {
        printf("Queue is Empty!\n");
        return;
    }
    printf("Queue: ");
    int i = front;
    while (1) {
        printf("%d ", queue[i]);
        if (i == rear) break;
        i = (i + 1) % SIZE;
    }
    printf("\n");
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);
    enqueue(40);
    enqueue(50);
    display();
    
    dequeue();
    dequeue();
    display();
    
    enqueue(60);
    enqueue(70);
    display();
    
    return 0;
}

✅ Fixes wasted space issue of normal queues.
✅ Efficient operations with O(1) time complexity.

---

(b) Circular Queue Using Linked List

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

struct Node {
    int data;
    struct Node* next;
};

struct Node *front = NULL, *rear = NULL;

// Check if the queue is empty
int isEmpty() {
    return (front == NULL);
}

// Insert an element
void enqueue(int value) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;

    if (isEmpty()) {
        front = rear = newNode;
        rear->next = front;  // Circular link
    } else {
        rear->next = newNode;
        rear = newNode;
        rear->next = front;  // Maintain circular connection
    }
    printf("Enqueued: %d\n", value);
}

// Remove an element
void dequeue() {
    if (isEmpty()) {
        printf("Queue is Empty!\n");
        return;
    }
    struct Node* temp = front;
    printf("Dequeued: %d\n", front->data);

    if (front == rear) {  // Single element in queue
        front = rear = NULL;
    } else {
        front = front->next;
        rear->next = front;
    }
    free(temp);
}

// Display the queue
void display() {
    if (isEmpty()) {
        printf("Queue is Empty!\n");
        return;
    }
    struct Node* temp = front;
    printf("Queue: ");
    do {
        printf("%d ", temp->data);
        temp = temp->next;
    } while (temp != front);
    printf("\n");
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);
    display();
    
    dequeue();
    display();
    
    return 0;
}

✅ Dynamic size (no fixed limit like array)
✅ Efficient for real-time processing

---

4️⃣ When is a Circular Queue Used?

💡 Circular Queues are used when:
✔ Fixed-size storage is needed (e.g., Buffer management, CPU scheduling).
✔ We want to reuse space efficiently after deletions.
✔ Low time complexity is required (O(1) enqueue & dequeue).