Scribd
Upload
89 views6 pages

Simulate A Stack, Queue, Circular Queue and Dequeue Using A One Dimensional

This C program implements and demonstrates various operations on stacks, queues, circular queues, and dequeues. It contains function definitions to push/pop elements from a stack, enqueue/dequeue elements from a queue and circular queue, and insert/delete elements at the front and rear of a dequeue. The main function uses a menu to allow the user to select an operation and demonstrate it by passing data to the appropriate function and displaying the results.

Uploaded by

Lakshya Sharma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
89 views6 pages

Simulate A Stack, Queue, Circular Queue and Dequeue Using A One Dimensional

This C program implements and demonstrates various operations on stacks, queues, circular queues, and dequeues. It contains function definitions to push/pop elements from a stack, enqueue/dequeue elements from a queue and circular queue, and insert/delete elements at the front and rear of a dequeue. The main function uses a menu to allow the user to select an operation and demonstrate it by passing data to the appropriate function and displaying the results.

Uploaded by

Lakshya Sharma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 6

#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");
}
}

You might also like