Queue (1)(1).ppt

NAGESH SHARMA, A.P. Department of CSE (AI), KIET Group of Institutions
SIMPLE QUEUE
SIMPLE QUEUE
(ARRAY IMPLEMENTATION)

• Some computer programming languages allow a module or
function to call itself.
• This technique is known as recursion.
• In recursion, a function α either calls itself directly or calls a
function β that in turn calls the original function α. The
function α is called recursive function.
• Using recursive algorithm, certain problems can be solved
quite easily.
• Examples of such problems are Tower of Hanoi (TOH),
Inorder/Preorder/Postorder Tree Traversal, DFS of Graph etc.
1/20/2023
2
Recursion (CO4)

• A recursive function can go infinite like a loop. To avoid
infinite running of recursive function, there are two properties
that a recursive function must have −
– Base criteria − There must be at least one base criteria or
condition, such that, when this condition is met the function
stops calling itself recursively.
– Progressive approach − The recursive calls should progress in
such a way that each time a recursive call is made it comes
closer to the base criteria.
• Example:-
int fact(int n)
{
if (n < = 1) // base case
return 1;
else
return n*fact(n-1); }
1/20/2023
3
Properties of Recursion

A function fun is called direct
recursive if it calls the same
function fun.
• // An example of direct
recursion
void directRecFun()
{
// Some code....
directRecFun();
// Some code...
}
A function fun is called indirect
recursive if it calls another function
say fun_new and fun_new calls fun
directly or indirectly.
• // An example of indirect
recursion
void indirectRecFun1()
{
// Some code...
IndirectRecFun2();
// Some code...
}
void indirectRecFun2()
{
// Some code...
indirectRecFun1();
// Some code...
}
1/20/2023
4
Direct and Indirect Recursion

• When any function is called from main(), the memory is
allocated to it on the stack. A recursive function calls itself,
the memory for a called function is allocated on top of
memory allocated to calling function and different copy of
local variables is created for each function call. When the base
case is reached, the function returns its value to the function
by whom it is called and memory is de-allocated and the
process continues.
• Example:-
int fact(int n)
{
if (n < = 1) // base case
return 1;
else
return n*fact(n-1); }
1/20/2023
5
Recursion Working

1/20/2023
6
Recursion Working (contd..)

1/20/2023
7
Factorial using Iteration
Int fact(int n)
{
int result=1;
for(i=n;i>=1;i--)
{
result=result*i;
}
return result;
}

• Fibonacci series
Int fib(int n)
{
if(n=0 or n=1)
return n;
else
return fib(n-1)+fib(n-
2);
}
• Power
int power(int a, int b)
{
if(b==0)
return 1;
else
return a*power(a, b-
1);
}
1/20/2023
8
More examples of recursion

• Advantage:-
– Recursion provides a clean and simple way to write code.
– Some problems are inherently recursive like tree
traversals, Tower of Hanoi, etc. For such problems, it is
preferred to write recursive code.
– We can write such codes also iteratively with the help of a stack
data structure.
• Disadvantage:-
– Every recursive program can be written iteratively and vice versa
is also true.
– The recursive program has greater space requirements than
iterative program as all functions will remain in the stack until
the base case is reached.
– It also has greater time requirements because of function calls
and returns overhead.
1/20/2023
9
Advantage and Disadvantage of
Recursion

• Tower of Hanoi, is a mathematical puzzle which consists of
three towers (pegs) and more than one rings is as depicted −
• These rings are of different sizes and stacked upon in an
ascending order, i.e. the smaller one sits over the larger one.
There are other variations of the puzzle where the number of
disks increase, but the tower count remains the same.
1/20/2023
10
Tower of Hanoi

• The mission is to move all the disks to some another tower
without violating the sequence of arrangement. A few rules to
be followed for Tower of Hanoi are −
– Only one disk can be moved among the towers at any
given time.
– Only the "top" disk can be removed.
– No large disk can sit over a small disk.
1/20/2023
11
Tower of Hanoi (Rules)

• We divide the stack of disks in two parts. The largest disk
(nth disk) is in one part and all other (n-1) disks are in the
second part.
• Our ultimate aim is to move disk n from source to destination
and then put all other (n-1) disks onto it. We can imagine to
apply the same in a recursive way for all given set of disks.
• The steps to follow are −
– Step 1 − Move n-1 disks from source to aux
– Step 2 − Move nth disk from source to dest
– Step 3 − Move n-1 disks from aux to dest
1/20/2023
12
Tower of Hanoi (Algorithm)

• Algorithm:-
START
Procedure Hanoi(disk, source, aux, dest)
IF disk == 1, THEN
move disk from source to dest
ELSE
Hanoi(disk - 1, source, dest, aux) // Step 1
move disk from source to dest // Step 2
Hanoi(disk - 1, aux, source, dest) // Step 3
END IF
END Procedure
STOP
1/20/2023
13
Tower of Hanoi (Algorithm)

1/20/2023
14
Tower of Hanoi (Example)
• A=Beginning, B=Auxillary, C=Destination
• If n is the number of disks then 2n-1 steps are required for
solving the problem.

1/20/2023
15
Iteration v/s Recursion

• Queue is an abstract data structure, somewhat similar to
Stacks. Unlike stacks, a queue is open at both its ends. One
end is always used to insert data (enqueue) and the other is
used to remove data (dequeue). Queue follows First-In-First-
Out methodology, i.e., the data item stored first will be
accessed first.
• A real-world example of queue can be a single-lane one-way
road, where the vehicle enters first, exits first. More real-
world examples can be seen as queues at the ticket windows
and bus-stops.
1/20/2023
16
Queues (CO1)

• As we now understand that in queue, we access both ends for
different reasons. The following diagram given below tries to
explain queue representation as data structure −
• As in stacks, a queue can also be implemented using Arrays,
Linked-lists
1/20/2023
17
Queue Representation

• A queue can be implemented by means of:-
– Array (Static Implementation)
– Linked List (Dynamic Implementation)
1/20/2023
18
Queue Implementation

• Queue operations may involve initializing or defining the
queue, utilizing it, and then completely erasing it from the
memory. Here we shall try to understand the basic operations
associated with queues −
– enqueue() − add (store) an item to the queue.
– dequeue() − remove (access) an item from the queue.
• In queue, we always dequeue (or access) data, pointed
by front pointer and while enqueing (or storing) data in the
queue we take help of rear pointer.
1/20/2023
19
Basic Operations

• Queues maintain two data pointers, front and rear.
Therefore, its operations are comparatively difficult to
implement than stacks.
• The following steps should be taken to enqueue (insert) data
into a queue
– Step 1 − Check if the queue is full.
– Step 2 − If the queue is full, produce overflow error and exit.
– Step 3 − If the queue is not full, increment rear pointer to
point the next empty space.
– Step 4 − Add data element to the queue location, where the
rear is pointing.
– Step 5 − return success.
1/20/2023
20
Enqueue Operation

• Implementation of enqueue() in C programming language −
• Example
int enqueue(int data)
if(isfull())
return 0;
rear = rear + 1;
queue[rear] = data;
return 1;
end procedure
1/20/2023
21
Enqueue Operation

• Accessing data from the queue is a process of two tasks −
access the data where front is pointing and remove the data
after access. The following steps are taken to
perform dequeue operation −
– Step 1 − Check if the queue is empty.
– Step 2 − If the queue is empty, produce underflow error and
exit.
– Step 3 − If the queue is not empty, access the data
where front is pointing.
– Step 4 − Increment front pointer to point to the next available
data element.
– Step 5 − Return success.
1/20/2023
22
Dequeue Operation

• Implementation of dequeue() in C programming language −
• Example
int dequeue()
{
if(isempty())
return 0;
int data = queue[front];
front = front + 1;
return data;
}
1/20/2023
23
Dequeue Operation

• A circular queue is an improvement over the standard queue
structure. In a standard queue, when an element is deleted,
the vacant space is not reutilized. However, in a circular
queue, vacant spaces are reutilized.
• While inserting elements, when you reach the end of an array
and you need to insert another element, you must insert that
element at the beginning (given that the first element has
been deleted and the space is vacant).
1/20/2023
24
Circular Queue

• The most common queue implementation is using arrays, but
it can also be implemented using lists.
• Array implementation:-
– https://www.programiz.com/dsa/circular-queue
1/20/2023
25
Circular Queue (Implementation)

• CPU scheduling
• Memory management
• Traffic Management
1/20/2023
26
Circular Queue Applications

• Dequeue or Double Ended Queue is a type of queue in which
insertion and removal of elements can be performed from
either from the front or rear.
• Thus, it does not follow FIFO rule (First In First Out).
• Types of Dequeue
– Input Restricted Deque
In this deque, input is restricted at a single end but allows
deletion at both the ends.
– Output Restricted Deque
In this deque, output is restricted at a single end but
allows insertion at both the ends.
1/20/2023
27
Dequeue

• Insert at the Front
• Insert at the Rear
• Delete from the Front
• Delete from the Rear
• Implementation of dequeue using array
– https://www.programiz.com/dsa/deque
1/20/2023
28
Operations on a Dequeue

• In undo operations on software.
• To store history in browsers.
• For implementing both stacks and queues.
1/20/2023
29
Dequeue Applications

• A priority queue is a special type of queue in which each
element is associated with a priority and is served according
to its priority.
• If elements with the same priority occur, they are served
according to their order in the queue.
1/20/2023
30
Priority Queue

PROGRAM TO IMPLEMENT SIMPLE QUEUE USING ARRAY
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 7
void display(int Queue[],int front,int rear)
{
int i;
if(front==-1)
{
printf("Queue is Emptyn");
return;
}
for(i=front;i<=rear;i++)
printf("%d ",Queue[i]);
printf("n");
}

FUNCTION : ENQUEUE OPERATION
void enqueue(int Queue[],int *front,int *rear,int item)
{ if(*rear==MAXSIZE-1)
{
printf("Overflown");
return;
}
if(*front==-1)
{
*front=0;
*rear=0;
}
else
*rear=*rear+1;
Queue[*rear]=item;
display(Queue,*front,*rear);
}

FUNCTION: DEQUEUE OPERATION
int dequeue(int Queue[],int *front,int *rear)
{
int x;
if(*front==-1)
{
printf("Underflown");
return -1;
}
x=Queue[*front];
if(*front==*rear)
*front=*rear=-1;
else
*front=*front+1;
display(Queue,*front,*rear);
return x;
}

MAIN() FUNCTION
int main()
{
int Queue[MAXSIZE];
int front=-1,rear=-1;
//display(Queue,front,rear);
enqueue(Queue,&front,&rear,1);
dequeue(Queue,&front,&rear);

MAIN() FUNCTION
return 0;
}

SIMPLE QUEUE
SIMPLE QUEUE
(LINKED LIST IMPLEMENTATION)

PROGRAM TO IMPLEMENT SIMPLE QUEUE LINKED LIST
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
struct node *next;
};
struct node *Allocate(int x)
{ struct node *nn=(struct node *)malloc(sizeof(struct node));
if(nn==NULL)
return NULL;
nn->data=x;
nn->next=NULL;
return nn;
};

void display(struct node *fr,struct node *re)
{
struct node *t;
if(fr==NULL)
{
printf("Queue is empty");
return;
}
for(t=fr;t!=re;t=t->next)
{
printf("%d -> ",t->data);
}
printf("%d ",t->data);
}

void enqueue(struct node **fr,struct node **re,int x)
{
struct node *nn=Allocate(x);
if(nn==NULL)
{
printf("nOverflow");
return;
}
if(*fr==NULL)
*fr=*re=nn;
else
{
(*re)->next=nn;
*re=nn;
}
}

int dequeue(struct node **fr,struct node **re)
{ int x;
struct node *temp;
if(*fr==NULL)
{
printf("nUnderflow");
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
*fr=(*fr)->next;
x=temp->data;
free(temp);
return x;
}

int main()
{ struct node *front=NULL,*rear=NULL;
int x;
enqueue(&front,&rear,1);
display(front,rear);
x=dequeue(&front,&rear);
if(x!=INT_MIN)
printf("n%d is deleted",x);

if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)

x=dequeue(&front, &rear);
if(x!=INT_MIN)
printf("n%d is deleted", x);
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

CIRCULAR QUEUE
CIRCULAR QUEUE

PROGRAM TO IMPLEMENT CIRCULAR QUEUE USING ARRAY
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
#define MAXSIZE 20
void display(int *Queue,int front, int rear)
{
int i;
if(front==-1)
{
printf("Queue is emptyn");
return;
}
for(i=front;i!=rear;i=(i+1)%MAXSIZE)
{
printf("%d ",Queue[i]);
}
printf("%d",Queue[i]);
}

void enqueue(int *Queue,int *front, int *rear,int x)
{
if(*front == (*rear+1)%MAXSIZE){
return;
}
if(*front==-1)
*front=*rear=0;
else
*rear=(*rear+1)%MAXSIZE;
Queue[*rear]=x;
}

int dequeue(int *Queue,int *front,int *rear)
{
int x;
if(*front==-1)
{
printf("Underflown");
return INT_MIN;
}
x=Queue[*front];
if(*front==*rear)
*front=*rear=-1;
else
*front=(*front+1)%MAXSIZE;
return x;
}

int main()
{
int Queue[MAXSIZE];
int front=-1,rear=-1,x;
display(Queue,front,rear);
x=dequeue(Queue,&front,&rear);
if(x!=INT_MIN)
printf("n%d is deletedn",x);

if(x!=INT_MIN)
printf("%d is deletedn",x);
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

CIRCULAR QUEUE
CIRCULAR QUEUE
LINKED LIST IMPLEMENTATION

PROGRAM TO IMPLEMENT CIRCULAR QUEUE LINKED LIST
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
struct node *next;
};
{
struct node *nn=(struct node *)malloc(sizeof(struct node));
if(nn==NULL)
return NULL;
nn->data=x;
nn->next=NULL;
return nn;
};

{
struct node *t;
if(fr==NULL)
{
return;
}
{
}
}

void enqueue(struct node **fr,struct node **re,int x)
{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
nn->next=nn;
*fr=*re=nn;
}
else
{
nn->next=*fr;
(*re)->next=nn;
*re=nn;
}
}

int dequeue(struct node **fr,struct node **re)
{ int x;
struct node *temp;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
{
*fr=(*fr)->next;
(*re)->next=*fr;
}
x=temp->data;
free(temp);
return x;
}

int main()
{ struct node *front=NULL,*rear=NULL;
int x;
if(x!=INT_MIN)

if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)

if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

PRIORITY QUEUE
PRIORITY QUEUE

PRIORITY QUEUE
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
#define MAXPR 5
#define MAXSIZE 5
int Q[MAXPR][MAXSIZE];
int front[MAXPR];
int rear[MAXPR];

PRIORITY QUEUE
void display()
{ int i,j;
for(i=0;i<MAXPR;i++)
{
for(j=0;j<MAXSIZE;j++)
{
if(Q[i][j]==INT_MIN)
printf(" ");
else
printf("%-2d ",Q[i][j]);
}
printf("Front[%d] = %2d, ",i,front[i]);
printf("Rear[%d] = %2d ",i,rear[i]);
printf("n");
}
}

PRIORITY QUEUE: ENQUEUE
void enqueue(int val,int prn)
{
if(prn<0 || prn>=MAXPR)
return;
if(rear[prn]==MAXSIZE-1)
{
printf("Overflow");
return;
}
if(front[prn]==-1)
{
front[prn]++;
}
rear[prn]++;
Q[prn][rear[prn]]=val;
}

PRIORITY QUEUE: DEQUEUE
int dequeue()
{ int i,x;
i=0;
while(i<MAXPR && front[i]==-1)
i++;
if(i==MAXPR)
{
return INT_MIN;
}
x=Q[i][front[i]];
Q[i][front[i]]=INT_MIN;
if(front[i]==rear[i]){
front[i]=-1;rear[i]=-1;
}
else
front[i]++;
return x;
}

PRIORITY QUEUE: MAIN()
int main()
{
int i,j,x;
for(i=0;i<MAXPR;i++)
{
front[i]=-1;
rear[i]=-1;
for(j=0;j<MAXSIZE;j++)
Q[i][j]=INT_MIN;
}
enqueue(5,1);
enqueue(6,2);
enqueue(7,1);
enqueue(28,4);
enqueue(5,2);
enqueue(3,2);
enqueue(23,0);
display();

PRIORITY QUEUE: MAIN()
x=dequeue();
printf("nn%d is deletednn",x);
display();
return 0;
}

PRIORITY QUEUE
PRIORITY QUEUE

PRIORITY QUEUE
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
int prn;
struct node *next;
};
struct node *Allocate(int val,int p)
{
struct node *nn=(struct node*)malloc(sizeof(struct node));
if(nn!=NULL)
{
nn->data=val;
nn->prn=p;
nn->next=NULL;
}
return nn;
};

PRIORITY QUEUE
void display(struct node *he)
{
struct node *cur;
if(he==NULL)
{
return ;
}
for(cur=he;cur->next!=NULL;cur=cur->next)
{
printf("(%d,%d)-> ",cur->data,cur->prn);
}
printf("(%d,%d)",cur->data,cur->prn);
}

PRIORITY QUEUE
void enqueue(struct node **he,int val,int p)
{
struct node *save,*cur;
struct node *nn=Allocate(val,p);
if(nn==NULL)
{
return;
}
if(*he==NULL || p<(*he)->prn)
{
nn->next=*he;
*he=nn;
return;
}

PRIORITY QUEUE
cur=*he;
while(cur!=NULL && p>=cur->prn)
{
save=cur;
cur=cur->next;
}
save->next=nn;
nn->next=cur;
}

PRIORITY QUEUE
int dequeue(struct node **he)
{
struct node *temp;
int x;
if(*he==NULL)
{
printf("nUnderflown");
return INT_MIN;
}
temp=*he;
*he=(*he)->next;
x=temp->data;
free(temp);
return x;
}

PRIORITY QUEUE
int main()
{
struct node *head= NULL;
int x;
enqueue(&head,15,4);
enqueue(&head,8,2);
enqueue(&head,6,7);
display(head);
x=dequeue(&head);
if(x!=INT_MIN)
x=dequeue(&head);
if(x!=INT_MIN)

PRIORITY QUEUE
x=dequeue(&head);
if(x!=INT_MIN)
x=dequeue(&head);
if(x!=INT_MIN)
x=dequeue(&head);
if(x!=INT_MIN)
x=dequeue(&head);
if(x!=INT_MIN)
x=dequeue(&head);
if(x!=INT_MIN)
return 0;
}

DEQUE
DOUBLE ENDED QUEUE
(DEQUE)
(SIMPLE INPUT RESTRICTED DEQUE)

INPUT RESTRICTED DEQUE
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
struct node *next;
};
{
if(nn==NULL)
return NULL;
nn->data=x;
nn->next=NULL;
return nn;
};

{
struct node *t;
if(fr==NULL)
{
return;
}
{
}
}

void enqueue_rear(struct node **fr,struct node **re,int x)
{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
*fr=*re=nn;
}
else
{
(*re)->next=nn;
*re=nn;
}
}

int dequeue_front(struct node **fr,struct node **re)
{
int x;
struct node *temp;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
*fr=(*fr)->next;
x=temp->data;
free(temp);
return x;
}

int dequeue_rear(struct node **fr,struct node **re)
{ int x;
struct node *temp,*save,*cur;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*re;
if(*fr==*re)
*fr=*re=NULL;
else
{
cur=*fr;
while(cur!=*re)
{
save=cur;
cur=cur->next;
}

save->next=NULL;
re=save;
}
x=temp->data;
free(temp);
return x;
}

int main()
{ int x;
struct node *front=NULL,*rear=NULL;
enqueue_rear(&front,&rear,1);
display(front, rear);
x=dequeue_front(&front,&rear);
if(x!=INT_MIN)
x=dequeue_rear(&front,&rear);
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

DEQUE
DOUBLE ENDED QUEUE
(DEQUE)
(SIMPLE OUTPUT RESTRICTED DEQUE)

OUPUT RESTRICTED DEQUE
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
struct node *next;
};
{
if(nn==NULL)
return NULL;
nn->data=x;
nn->next=NULL;
return nn;
};

{
struct node *t;
if(fr==NULL)
{
return;
}
{
}
}

{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
*fr=*re=nn;
}
else
{
(*re)->next=nn;
*re=nn;
}
}

void enqueue_front(struct node **fr,struct node **re,int x)
{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
*fr=*re=nn;
}
else
{
nn->next=*fr;
*fr=nn;
}
}

{
int x;
struct node *temp;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
*fr=(*fr)->next;
x=temp->data;
free(temp);
return x;
}

int main()
{ int x;
enqueue_front(&front,&rear,2);
display(front, rear);
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

DEQUE
DOUBLE ENDED QUEUE
(DEQUE)
(CIRCULAR INPUT RESTRICTED DEQUE)

{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
nn->next=nn;
*fr=*re=nn;
}
else
{
nn->next=*fr;
(*re)->next=nn;
*re=nn;
}
}

{ int x;
struct node *temp;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
{
*fr=(*fr)->next;
(*re)->next=*fr;
}
x=temp->data;
free(temp);
return x;
}

{ int x;
struct node *cur,*save;
if(*re==NULL)
{
return INT_MIN;
}
cur=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
{
cur=*fr;
while(cur!=*re)
{
save=cur;
cur=cur->next;
}

save->next=*fr;
*re=save;
}
x=cur->data;
free(cur);
return x;
}

int main()
{
int x;
if(x!=INT_MIN)
if(x!=INT_MIN)

if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

DEQUE
DOUBLE ENDED QUEUE
(DEQUE)
(CIRCULAR OUTPUT RESTRICTED DEQUE)

OUTPUT RESTRICTED DEQUE
#include <stdio.h>
#include <stdlib.h>
#include<limits.h>
struct node
{
int data;
struct node *next;
};
{
if(nn==NULL)
return NULL;
nn->data=x;
nn->next=NULL;
return nn;
};

{
struct node *t;
if(fr==NULL)
{
return;
}
{
}
}

{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
nn->next=nn;
*fr=*re=nn;
}
else
{
nn->next=*fr;
(*re)->next=nn;
*re=nn;
}
}

void enqueue_front(struct node **fr,struct node **re,int x)
{
if(nn==NULL)
{
return;
}
if(*fr==NULL)
{
nn->next=nn;
*fr=*re=nn;
}
else
{
nn->next=*fr;
(*re)->next=nn;
*fr=nn;
}
}

{ int x;
struct node *temp;
if(*fr==NULL)
{
return INT_MIN;
}
temp=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
{
*fr=(*fr)->next;
(*re)->next=*fr;
}
x=temp->data;
free(temp);
return x;
}

{ int x;
struct node *cur,*save;
if(*re==NULL)
{
return INT_MIN;
}
cur=*fr;
if(*fr==*re)
*fr=*re=NULL;
else
{
cur=*fr;
while(cur!=*re)
{
save=cur;
cur=cur->next;
}

save->next=*fr;
*re=save;
}
x=cur->data;
free(cur);
return x;
}

int main()
{
int x;
if(x!=INT_MIN)
if(x!=INT_MIN)

if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
if(x!=INT_MIN)
return 0;
}

Queue (1)(1).ppt

Recommended

Recommended

More Related Content

Similar to Queue (1)(1).ppt

Similar to Queue (1)(1).ppt (20)

Recently uploaded

Recently uploaded (20)

Queue (1)(1).ppt