C program for the two dimensional array repesentation of priority queue?

Answer 1

//implement double ended queue using array.

#include<stdio.h>

#include<conio.h>

#define SIZE 20

typedef struct dq_t

{

int front,rear;

int item[SIZE];

}deque;

/********** Function Declaration begins **********/

void create(deque *);

void display(deque *);

void insert_rear(deque *, int);

void insert_front(deque *, int);

int delete_front(deque *, int);

int delete_rear(deque *, int);

/********** Function Declaration ends **********/

void main()

{

int data,ch,x;

deque DQ;

clrscr();

create(&DQ);

printf("\n\t\t Program shows working of double ended queue");

do

{

printf("\n\t\t Menu");

printf("\n\t\t 1: insert at rear end");

printf("\n\t\t 2: insert at front end");

printf("\n\t\t 3: delete from front end");

printf("\n\t\t 4: delete from rear end");

printf("\n\t\t 5: exit. ");

printf("\n\t\t Enter choice :");

scanf("%d",&ch);

switch(ch)

{

case 1:

if (DQ.rear >= SIZE)

{

printf("\n Deque is full at rear end");

continue;

}

else

{

printf("\n Enter element to be added at rear end :");

scanf("%d",&data);

insert_rear(&DQ,data);

printf("\n Elements in a deque are :");

display(&DQ);

continue;

}

case 2:

if (DQ.front <=0)

{

printf("\n Deque is full at front end");

continue;

}

else

{

printf("\n Enter element to be added at front end :");

scanf("%d",&data);

insert_front(&DQ,data);

printf("\n Elements in a deque are :");

display(&DQ);

continue;

}

case 3:

x = delete_front(&DQ,data);

if (DQ.front==0)

{

continue;

}

else

{

printf("\n Elements in a deque are :");

display(&DQ);

continue;

}

case 4:

x = delete_rear(&DQ,data);

if (DQ.rear==0)

{

continue;

}

else

{

printf("\n Elements in a deque are :");

display(&DQ);

continue;

}

case 5: printf("\n finish");

return;

}

}

while(ch!=5);

getch();

}

/********** Creating an empty double ended queue **********/

/********** Function Definition begins **********/

void create(deque *DQ)

{

DQ->front=0;

DQ->rear =0;

}

/********** Function Definition ends **********/

/********** Inserting element at rear end **********/

/********** Function Definition begins **********/

void insert_rear(deque *DQ, int data)

{

if ((DQ->front 0)

{

printf("\n Underflow");

return(0);

}

else

{

DQ->rear = DQ->rear -1;

data = DQ->item[DQ->rear];

printf("\n Element %d is deleted from rear:",data);

}

if (DQ->front==DQ->rear)

{

DQ->front =0;

DQ->rear = 0;

printf("\n Deque is empty(rear end)");

}

return data;

}

/********** Function Definition ends **********/

/********** Displaying elements of DEQUE **********/

/********** Function Definition begins **********/

void display(deque *DQ)

{

int x;

for(x=DQ->front;x<DQ->rear;x++)

{

printf("%d\t",DQ->item[x]);

}

printf("\n\n");

}

/********** Function Definition ends **********/

Answer 2

If this is a homework assignment, you really should consider trying it yourself, first.

A linear queue is a first-in, first-out structure, similar to a line of people at a check-out register in a store. Using an array as the list of pointers to strings, one way to do this is... (A circular queue)

This example uses ellipses (...) to represent tabs for clarity

#define MAX_Q_SIZE (1000) /* or whatever max size you want */
char *queue[MAX_Q_SIZE];
int in_index = 0;
int out_index = 0;

int insert(char *str) {
... if ((in_index + 1) % MAX_Q_SIZE == out_index) return 0; /* error - queue full */
... queue[in_index] = str;
... in_index = (in_index + 1) % MAX_Q_SIZE;
... return 1; /* success */
}

char* remove() {
... char *temp;
... if (in_index == out_index) return null; /* queue empty */
... temp = queue[out_index];
... out_index = (out_index + 1) % MAX_Q_SIZE;
... return temp; /* success */
}

Answer 3

#include<stdio.h>

#include<conio.h>

#define MAXSIZE 4

void pqinsert();

void pqdelete();

void display();

int pqueue[3][MAXSIZE];

int front[3]={0,0,0};

int rear[3]={-1,-1,-1};

int item,pr;

void main()

{

char ch;

int choice;

clrscr();

do

{

printf("\n*************** Queue Operations **************\n");

printf("\t\t 1-> PQInsert\n");

printf("\t\t 2-> PQDelete\n");

printf("\t\t 3-> Display\n");

printf("\t\t 4-> Exit\n");

printf("\t\t Enter your choice:");

scanf("%d",&choice);

switch(choice)

{

case 1: printf("\t\t Enter the priority:");

scanf("%d",&pr);

if(pr>0 && pr<4)

pqinsert(pr-1);

else

printf("\t\t Invalid priority\n");

break;

case 2: pqdelete();

break;

case 3: display();

break;

case 4: exit(0);

break;

default: printf("\t\tInvalid choice\n");

break;

}

printf("\t\tDo you want to continue(type y or n):");

fflush(stdin);

scanf("%c",&ch);

} while(ch!='n');

getch();

}

void pqinsert(int pr)

{

int item;

if(rear[pr]==MAXSIZE-1)

printf("\t\t PQueue Overflows\n");

else

{

printf("\t\t Enter the element:");

scanf("%d",&item);

rear[pr]++;

pqueue[pr][rear[pr]]=item;

}

}

void pqdelete()

{

static int i=0 ;

if(rear[i]==front[i]-1)

{

printf("\t\t Queue %d Underflows\n",i+1);

i++;

}

else

{

printf("\t\t The deleted element is %d of queue %d:\n",pqueue[i][front[i]],i+1);

front[i]++;

}

}

}

void display()

{

int i,j;

for(i=0;i<3;i++)

{

if(rear[i]==front[i]-1)

printf("\t\t Queue %d Underflows\n:",i+1);

else

{

printf("\t\tThe elements in Queue %d are\n",i+1);

printf("\t");

for(j=front[i];j<=rear[i];j++)

printf("\t%d",pqueue[i][j]);

printf("\n");

}

}

}