// Standard Queue implementation in C

#include <stdio.h>
#define SIZE 5

void enQueue(int);
void deQueue();
void display();

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

int main() {
//deQueue is not possible on empty queue
deQueue();

//enQueue 5 elements
enQueue(1);
enQueue(2);
enQueue(3);
enQueue(4);
enQueue(5);

// 6th element can't be added to because the queue is full

enQueue(6);

display();

//deQueue removes element entered first i.e. 1

deQueue();

//Now we have just 4 elements

display();

return 0;
}

void enQueue(int value) {

if (rear == SIZE - 1)
printf("\nQueue is Full!!");
else {
if (front == -1)
front = 0;
rear++;
items[rear] = value;
printf("\nInserted -> %d", value);
}
}
void deQueue() {
if (front == -1)
printf("\nQueue is Empty!!");
else {
printf("\nDeleted : %d", items[front]);
front++;
if (front > rear)
front = rear = -1;
}
}

// Function to print the queue

void display() {
if (rear == -1)
printf("\nQueue is Empty!!!");
else {
int i;
printf("\nQueue elements are:\n");
for (i = front; i <= rear; i++)
printf("%d ", items[i]);
}
printf("\n");
}

Output

Queue is Empty!!
Inserted -> 1
Inserted -> 2
Inserted -> 3
Inserted -> 4
Inserted -> 5
Queue is Full!!
Queue elements are:
1 2 3 4 5

Deleted : 1
Queue elements are:
2 3 4 5
// Circular Queue implementation in C

#include <stdio.h>

#define SIZE 5

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

// Check if the queue is full

int isFull() {
if ((front == rear + 1) || (front == 0 && rear == SIZE - 1)) return 1;
return 0;
}

// Check if the queue is empty

int isEmpty() {
if (front == -1) return 1;
return 0;
}

// Adding an element
void enQueue(int element) {
if (isFull())
printf("\n Queue is full!! \n");
else {
if (front == -1) front = 0;
rear = (rear + 1) % SIZE;
items[rear] = element;
printf("\n Inserted -> %d", element);
}
}

// Removing an element
int deQueue() {
int element;
if (isEmpty()) {
printf("\n Queue is empty !! \n");
return (-1);
} else {
element = items[front];
if (front == rear) {
front = -1;
rear = -1;
}
// Q has only one element, so we reset the
 // queue after dequeing it. ?
else {
front = (front + 1) % SIZE;
}
printf("\n Deleted element -> %d \n", element);
return (element);
}
}

// Display the queue

void display() {
int i;
if (isEmpty())
printf(" \n Empty Queue\n");
else {
printf("\n Front -> %d ", front);
printf("\n Items -> ");
for (i = front; i != rear; i = (i + 1) % SIZE) {
printf("%d ", items[i]);
}
printf("%d ", items[i]);
printf("\n Rear -> %d \n", rear);
}
}

int main() {
// Fails because front = -1
deQueue();

enQueue(1);
enQueue(2);
enQueue(3);
enQueue(4);
enQueue(5);

// Fails to enqueue because front == 0 && rear == SIZE - 1

enQueue(6);

display();
deQueue();

display();

enQueue(7);
display();
 // Fails to enqueue because front == rear + 1
enQueue(8);

return 0;
}

Output

Queue is empty !!
Inserted -> 1
Inserted -> 2
Inserted -> 3
Inserted -> 4
Inserted -> 5
Queue is full!!
Front -> 0
Items -> 1 2 3 4 5
Rear -> 4
Deleted element -> 1
Front -> 1
Items -> 2 3 4 5
Rear -> 4
Inserted -> 7
Front -> 1
Items -> 2 3 4 5 7
Rear -> 0
Queue is full!!
// Priority Queue Implementation in C using array

#include <stdio.h>
#include <stdlib.h>
#define MAX 10

void create_queue();
void insert_element(int);
void delete_element(int);
void check_priority(int);
void display_priorityqueue();

int pqueue[MAX];
int front, rear;

void main()
{
int n, choice;
printf("\nEnter 1 to insert element by priority ");
printf("\nEnter 2 to delete element by priority ");
printf("\nEnter 3 to display priority queue ");
printf("\nEnter 4 to exit");
create_queue();
while (1)
{
printf("\nEnter your choice : ");
scanf("%d", &choice);
switch(choice)
{
case 1:
printf("\nEnter element to insert : ");
scanf("%d",&n);
insert_element(n);
break;
case 2:
printf("\nEnter element to delete : ");
scanf("%d",&n);
delete_element(n);
break;
case 3:
display_priorityqueue();
break;
case 4:
exit(0);
default:
printf("\n Please enter valid choice");
 }
}
}
void create_queue()
{
front = rear = -1;
}
void insert_element(int data)
{
if (rear >= MAX - 1)
{
printf("\nQUEUE OVERFLOW");
return;
}
if ((front == -1) && (rear == -1))
{
front++;
rear++;
pqueue[rear] = data;
return;
}
else
check_priority(data);
rear++;
}
void check_priority(int data)
{
int i,j;
for (i = 0; i <= rear; i++)
{
if (data >= pqueue[i])
{
for (j = rear + 1; j > i; j--)
{
pqueue[j] = pqueue[j - 1];
}
pqueue[i] = data;
return;
}
}
pqueue[i] = data;
}
void delete_element(int data)
{
int i;
if ((front==-1) && (rear==-1))
 {
printf("\nEmpty Queue");
return;
}
for (i = 0; i <= rear; i++)
{
if (data == pqueue[i])
{
for (; i < rear; i++)
{
pqueue[i] = pqueue[i + 1];
}
pqueue[i] = -99;
rear--;
if (rear == -1)
front = -1;
return;
}
}
printf("\n%d element not found in queue", data);
}
void display_priorityqueue()
{
if ((front == -1) && (rear == -1))
{
printf("\nEmpty Queue ");
return;
}
for (; front <= rear; front++)
{
printf(" %d ", pqueue[front]);
}
front = 0;
}

Output

Enter 1 to insert element by priority

Enter 2 to delete element by priority
Enter 3 to display priority queue
Enter 4 to exit
Enter your choice : 1
Enter element to insert : 10
Enter your choice : 3
10
Enter your choice : 1
Enter element to insert : 11
Enter your choice : 1
Enter element to insert : 3
Enter your choice : 1
Enter element to insert : 4
Enter your choice : 1
Enter element to insert : 8
Enter your choice : 3
11 10 8 4 3
Enter your choice : 2
Enter element to delete : 10
Enter your choice : 3
11 8 4 3
Enter your choice : 4
// C Program implementation of Priority Queue – Unordered using array (Max Priority
Queue)
// to implement min priority queue you can just change greater than sign to smaller than
at // the time of comparison and initialisation of maxPriority

#include<stdio.h>
#include<limits.h>

#define MAX 100

// denotes where the last item in priority queue is

// initialized to -1 since no item is in queue
int idx = -1;

// pqVal holds data for each index item

// pqPriority holds priority for each index item
int pqVal[MAX];
int pqPriority[MAX];

int isEmpty ()
{
return idx == -1;
}

int
isFull ()
{
return idx == MAX - 1;
}

// enqueue just adds item to the end of the priority queue | O(1)
void enqueue (int data, int priority)
{
if (!isFull ())
{
// Increase the index
idx++;

// Insert the element in priority queue

pqVal[idx] = data;
pqPriority[idx] = priority;
}
}
// returns item with highest priority
// NOTE: Max Priority Queue High priority number means higher priority | O(N)
int peek ()
{
// Note : Max Priority, so assigned min value as initial value
int maxPriority = INT_MIN;
int indexPos = -1;

// Linear search for highest priority

for (int i = 0; i <= idx; i++)
{
// If two items have same priority choose the one with
// higher data value
if (maxPriority == pqPriority[i] && indexPos > -1
&& pqVal[indexPos] < pqVal[i])
{
maxPriority = pqPriority[i];
indexPos = i;
}
// note: using MAX Priority so higher priority number
// means higher priority
else if (maxPriority < pqPriority[i])
{
maxPriority = pqPriority[i];
indexPos = i;
}
}
// Return index of the element where
return indexPos;
}

// This removes the element with highest priority

// from the priority queue | O(N)
void dequeue ()
{
if (!isEmpty ())
{
// Get element with highest priority
int indexPos = peek ();

// reduce size of priority queue by first

// shifting all elements one position left
// from index where the highest priority item was found
for (int i = indexPos; i < idx; i++)
{
pqVal[i] = pqVal[i + 1];
pqPriority[i] = pqPriority[i + 1];
}
// reduce size of priority queue by 1
 idx--;
}
}

void display ()
{
for (int i = 0; i <= idx; i++)
{
printf ("(%d, %d)\n", pqVal[i], pqPriority[i]);
}
}

int main ()
{
// To enqueue items as per priority
enqueue (5, 1);
enqueue (10, 3);
enqueue (15, 4);
enqueue (20, 5);
enqueue (500, 2);

printf ("Before Dequeue : \n");

display ();

// Dequeue the top element

dequeue (); // 20 dequeued
dequeue (); // 15 dequeued

printf ("\nAfter Dequeue : \n");

display ();

return 0;
}

Output

Before Dequeue :
(5, 1)
(10, 3)
(15, 4)
(20, 5)
(500, 2)
After Dequeue :
(5, 1)
(10, 3)
(500, 2)
// C Program implementation of Priority Queue – Ordered using array (Max Priority
Queue)
// to implement min priority queue you can just change greater than sign to smaller than
at // the time of comparison and initialisation of maxPriority

#include<stdio.h>
#include<limits.h>
#define MAX 100

// denotes where the last item in priority queue is

// initialized to -1 since no item is in queue
int idx = -1;

// pqVal holds data for each index item

// pqPriority holds priority for each index item
int pqVal[MAX];
int pqPriority[MAX];

int isEmpty ()
{
return idx == -1;
}

int
isFull ()
{
return idx == MAX - 1;
}

// Insert the element in maintaining items in sorted order

// of their priority
void enqueue (int data, int priority)
{
if (!isFull ())
{
// first item being entered
if (idx == -1)
{
idx++; // increase the index
pqVal[idx] = data;
pqPriority[idx] = priority;
return;
}
else
{
// Increase the index
 idx++;
// in reverse order
for (int i = idx - 1; i >= 0; i--)
{
// shift all items rightwards with higher priority
// than the element we trying to insert
if (pqPriority[i] >= priority)
{
pqVal[i + 1] = pqVal[i];
pqPriority[i + 1] = pqPriority[i];
}
else
{
// insert item just before where
// lower priority index was found
pqVal[i + 1] = data;
pqPriority[i + 1] = priority;
break;
}
}
}
}
}

// returns item with highest priority

// note highest priority in max priority queue is last item in array
int peek ()
{
return idx;
}

// just reducing index would mean we have dequed

// the value would be sitll there but we can say that
// no more than a garbage value
void dequeue ()
{
idx--;
}

void display ()
{
for (int i = 0; i <= idx; i++)
{
printf ("(%d, %d)\n", pqVal[i], pqPriority[i]);
}
}

int main ()
{
// To enqueue items as per priority
enqueue (25, 1);
enqueue (10, 10);
enqueue (15, 50);
enqueue (20, 100);
enqueue (30, 5);
enqueue (40, 7);

printf ("Before Dequeue : \n");

display ();

// // Dequeue the top element

dequeue (); // 20 dequeued
dequeue (); // 15 dequeued

printf ("\nAfter Dequeue : \n");

display ();

return 0;
}

Output

Before Dequeue :
(25, 1)
(30, 5)
(40, 7)
(10, 10)
(15, 50)
(20, 100)
After Dequeue :
(25, 1)
(30, 5)
(40, 7)
(10, 10)
// C Program for Deque using array

// Deque implementation in C

#include <stdio.h>

#define MAX 10

void addFront(int *, int, int *, int *);

void addRear(int *, int, int *, int *);
int delFront(int *, int *, int *);
int delRear(int *, int *, int *);
void display(int *);
int count(int *);

int main() {
int arr[MAX];
int front, rear, i, n;

front = rear = -1;

for (i = 0; i < MAX; i++)
arr[i] = 0;

addRear(arr, 5, &front, &rear);

addFront(arr, 12, &front, &rear);
addRear(arr, 11, &front, &rear);
addFront(arr, 5, &front, &rear);
addRear(arr, 6, &front, &rear);
addFront(arr, 8, &front, &rear);

printf("\nElements in a deque: ");

display(arr);

i = delFront(arr, &front, &rear);

printf("\nremoved item: %d", i);

printf("\nElements in a deque after deletion: ");

display(arr);

addRear(arr, 16, &front, &rear);

addRear(arr, 7, &front, &rear);

printf("\nElements in a deque after addition: ");

display(arr);

i = delRear(arr, &front, &rear);

 printf("\nremoved item: %d", i);

printf("\nElements in a deque after deletion: ");

display(arr);

n = count(arr);
printf("\nTotal number of elements in deque: %d", n);
}

void addFront(int *arr, int item, int *pfront, int *prear) {

int i, k, c;

if (*pfront == 0 && *prear == MAX - 1) {

printf("\nDeque is full.\n");
return;
}

if (*pfront == -1) {
*pfront = *prear = 0;
arr[*pfront] = item;
return;
}

if (*prear != MAX - 1) {
c = count(arr);
k = *prear + 1;
for (i = 1; i <= c; i++) {
arr[k] = arr[k - 1];
k--;
}
arr[k] = item;
*pfront = k;
(*prear)++;
} else {
(*pfront)--;
arr[*pfront] = item;
}
}

void addRear(int *arr, int item, int *pfront, int *prear) {

int i, k;

if (*pfront == 0 && *prear == MAX - 1) {

printf("\nDeque is full.\n");
return;
}
 if (*pfront == -1) {
*prear = *pfront = 0;
arr[*prear] = item;
return;
}

if (*prear == MAX - 1) {
k = *pfront - 1;
for (i = *pfront - 1; i < *prear; i++) {
k = i;
if (k == MAX - 1)
arr[k] = 0;
else
arr[k] = arr[i + 1];
}
(*prear)--;
(*pfront)--;
}
(*prear)++;
arr[*prear] = item;
}

int delFront(int *arr, int *pfront, int *prear) {

int item;

if (*pfront == -1) {
printf("\nDeque is empty.\n");
return 0;
}

item = arr[*pfront];
arr[*pfront] = 0;

if (*pfront == *prear)
*pfront = *prear = -1;
else
(*pfront)++;

return item;
}

int delRear(int *arr, int *pfront, int *prear) {

int item;

if (*pfront == -1) {
 printf("\nDeque is empty.\n");
return 0;
}

item = arr[*prear];
arr[*prear] = 0;
(*prear)--;
if (*prear == -1)
*pfront = -1;
return item;
}

void display(int *arr) {

int i;

printf("\n front: ");

for (i = 0; i < MAX; i++)
printf(" %d", arr[i]);
printf(" :rear");
}

int count(int *arr) {

int c = 0, i;

for (i = 0; i < MAX; i++) {

if (arr[i] != 0)
c++;
}
return c;
}

Output

Elements in a deque:
front: 8 5 12 5 11 6 0 0 0 0 :rear
removed item: 8
Elements in a deque after deletion:
front: 0 5 12 5 11 6 0 0 0 0 :rear
Elements in a deque after addition:
front: 0 5 12 5 11 6 16 7 0 0 :rear
removed item: 7
Elements in a deque after deletion:
front: 0 5 12 5 11 6 16 0 0 0 :rear
Total number of elements in deque: 6