#include <stdio.

h>
#include <stdlib.h>

#define MAX_SIZE 10

// Function prototypes
void push(int stack[], int *top, int element);
int pop(int stack[], int *top);
void enqueue(int queue[], int *front, int *rear, int element);
int dequeue(int queue[], int *front, int *rear);
void enqueueCircular(int circularQueue[], int *front, int *rear, int element);
int dequeueCircular(int circularQueue[], int *front, int *rear);
void insertFront(int dequeue[], int *front, int element);
void insertRear(int dequeue[], int *rear, int element);
int deleteFront(int dequeue[], int *front);
int deleteRear(int dequeue[], int *rear);
void display(int array[], int front, int rear, char *name);

int main() {
int stack[MAX_SIZE], queue[MAX_SIZE], circularQueue[MAX_SIZE],
dequeue[MAX_SIZE];
int top = -1, frontQ = -1, rearQ = -1, frontCQ = -1, rearCQ = -1, frontDQ = -1,
rearDQ = -1;
int choice, element;

do {
printf("\n1. Push (Stack)\n");
printf("2. Pop (Stack)\n");
printf("3. Enqueue (Queue)\n");
printf("4. Dequeue (Queue)\n");
printf("5. Enqueue (Circular Queue)\n");
printf("6. Dequeue (Circular Queue)\n");
printf("7. Insert Front (Dequeue)\n");
printf("8. Insert Rear (Dequeue)\n");
printf("9. Delete Front (Dequeue)\n");
printf("10. Delete Rear (Dequeue)\n");
printf("11. Display\n");
printf("0. Exit\n");
printf("Enter your choice: ");
scanf("%d", &choice);

switch (choice) {
case 1:
printf("Enter element to push: ");
scanf("%d", &element);
push(stack, &top, element);
break;

case 2:
element = pop(stack, &top);
if (element != -1)
printf("Popped element: %d\n", element);
break;

case 3:
printf("Enter element to enqueue: ");
scanf("%d", &element);
enqueue(queue, &frontQ, &rearQ, element);
break;
case 4:
element = dequeue(queue, &frontQ, &rearQ);
if (element != -1)
printf("Dequeued element: %d\n", element);
break;

case 5:
printf("Enter element to enqueue in circular queue: ");
scanf("%d", &element);
enqueueCircular(circularQueue, &frontCQ, &rearCQ, element);
break;

case 6:
element = dequeueCircular(circularQueue, &frontCQ, &rearCQ);
if (element != -1)
printf("Dequeued element from circular queue: %d\n", element);
break;

case 7:
printf("Enter element to insert at front in dequeue: ");
scanf("%d", &element);
insertFront(dequeue, &frontDQ, element);
break;

case 8:
printf("Enter element to insert at rear in dequeue: ");
scanf("%d", &element);
insertRear(dequeue, &rearDQ, element);
break;

case 9:
element = deleteFront(dequeue, &frontDQ);
if (element != -1)
printf("Deleted element from front of dequeue: %d\n", element);
break;

case 10:
element = deleteRear(dequeue, &rearDQ);
if (element != -1)
printf("Deleted element from rear of dequeue: %d\n", element);
break;

case 11:
printf("\nStack:\n");
display(stack, 0, top, "Stack");

printf("\nQueue:\n");
display(queue, frontQ, rearQ, "Queue");

printf("\nCircular Queue:\n");
display(circularQueue, frontCQ, rearCQ, "Circular Queue");

printf("\nDequeue:\n");
display(dequeue, frontDQ, rearDQ, "Dequeue");
break;

case 0:
printf("Exiting the program. Goodbye!\n");
 break;

default:
printf("Invalid choice. Please enter a valid option.\n");
}
} while (choice != 0);

return 0;
}

// Function to push an element onto the stack

void push(int stack[], int *top, int element) {
if (*top == MAX_SIZE - 1) {
printf("Stack Overflow. Cannot push element.\n");
} else {
(*top)++;
stack[*top] = element;
printf("Pushed %d onto the stack.\n", element);
}
}

// Function to pop an element from the stack

int pop(int stack[], int *top) {
if (*top == -1) {
printf("Stack Underflow. Cannot pop element.\n");
return -1;
} else {
int element = stack[*top];
(*top)--;
return element;
}
}

// Function to enqueue an element into the queue

void enqueue(int queue[], int *front, int *rear, int element) {
if (*rear == MAX_SIZE - 1) {
printf("Queue Overflow. Cannot enqueue element.\n");
} else {
if (*front == -1) {
*front = 0;
}
(*rear)++;
queue[*rear] = element;
printf("Enqueued %d into the queue.\n", element);
}
}

// Function to dequeue an element from the queue

int dequeue(int queue[], int *front, int *rear) {
if (*front == -1) {
printf("Queue Underflow. Cannot dequeue element.\n");
return -1;
} else {
int element = queue[*front];
if (*front == *rear) {
*front = -1;
*rear = -1;
} else {
(*front)++;
 }
return element;
}
}

// Function to enqueue an element into the circular queue

void enqueueCircular(int circularQueue[], int *front, int *rear, int element) {
int nextRear = (*rear + 1) % MAX_SIZE;

if (nextRear == *front) {
printf("Circular Queue Overflow. Cannot enqueue element.\n");
} else {
*rear = nextRear;
circularQueue[*rear] = element;
if (*front == -1) {
*front = 0;
}
printf("Enqueued %d into the circular queue.\n", element);
}
}

// Function to dequeue an element from the circular queue

int dequeueCircular(int circularQueue[], int *front, int *rear) {
if (*front == -1) {
printf("Circular Queue Underflow. Cannot dequeue element.\n");
return -1;
} else {
int element = circularQueue[*front];
if (*front == *rear) {
*front = -1;
*rear = -1;
} else {
*front = (*front + 1) % MAX_SIZE;
}
return element;
}
}

// Function to insert an element at the front of the dequeue

void insertFront(int dequeue[], int *front, int element) {
if ((*front == 0 && rearDQ == MAX_SIZE - 1) || (*front == rearDQ + 1)) {
printf("Dequeue Overflow. Cannot insert element at the front.\n");
} else {
if (*front == -1) {
*front = 0;
*rear = 0;
} else if (*front == 0) {
*front = MAX_SIZE - 1;
} else {
(*front)--;
}
dequeue[*front] = element;
printf("Inserted %d at the front of the dequeue.\n", element);
}
}

// Function to insert an element at the rear of the dequeue

void insertRear(int dequeue[], int *rear, int element) {
if ((*front == 0 && *rear == MAX_SIZE - 1) || (*front == *rear + 1)) {
 printf("Dequeue Overflow. Cannot insert element at the rear.\n");
} else {
if (*front == -1) {
*front = 0;
*rear = 0;
} else if (*rear == MAX_SIZE - 1) {
*rear = 0;
} else {
(*rear)++;
}
dequeue[*rear] = element;
printf("Inserted %d at the rear of the dequeue.\n", element);
}
}

// Function to delete an element from the front of the dequeue

int deleteFront(int dequeue[], int *front) {
if (*front == -1) {
printf("Dequeue Underflow. Cannot delete element from the front.\n");
return -1;
} else {
int element = dequeue[*front];
if (*front == *rear) {
*front = -1;
*rear = -1;
} else if (*front == MAX_SIZE - 1) {
*front = 0;
} else {
(*front)++;
}
return element;
}
}

// Function to delete an element from the rear of the dequeue

int deleteRear(int dequeue[], int *rear) {
if (*front == -1) {
printf("Dequeue Underflow. Cannot delete element from the rear.\n");
return -1;
} else {
int element = dequeue[*rear];
if (*front == *rear) {
*front = -1;
*rear = -1;
} else if (*rear == 0) {
*rear = MAX_SIZE - 1;
} else {
(*rear)--;
}
return element;
}
}

// Function to display the elements of an array

void display(int array[], int front, int rear, char *name) {
if (front == -1) {
printf("%s is empty.\n", name);
} else {
printf("%s elements: ", name);
 int i = front;
do {
printf("%d ", array[i]);
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
printf("\n");
}
}