Data Structures Using C

STACK ADT

3.1 INTRODUCTION
Let we consider, five discs are placed one over the other through a shaft. If we want to
insert a new disc say ‘disc 6’, it is only possible to insert the disc on the top of “disc 5”. Because
of the presence of shaft, it is not possible to insert the disc 6 in the middle of discs in the shaft.
Similarly, if we want to remove “disc 4”, it is only possible to remove “disc 5” before “disc4”.
These similar operations are carried out in Stack ADT.

♣ Stack is an ordered collection of element in which insertion & deletion operations are
restricted to one end of list.
♣ The end from which elements are added or removed to or from the list is referred as a
“TOP” of Stack.
♣ It is also referred as “Push-Down List” or “Piles”.
♣ The first element placed in the stack will be at the bottom of stack.
♣ The last element placed in the stack will be at the top of stack.
♣ The last element added to the stack is the first element to be removed. Hence stack is
referred as Last-In-First-Out (LIFO) or First-In-Last-Out (FILO) ADT.

3.2 OPERATIONS ON STACK ADT

The primary operations that can be carried on the Stack ADT are insertion & deletion
which are named as PUSH & POP respectively. These operations are carried out with the help
of Top Pointer which always points or keeps track of top element of stack. The top pointer keeps
track of, top element in the stack i.e. Last inserted element. One more operation called PEEK.

1. PUSH operation insert new element onto the top of stack.

2. POP operation deletes an element from the top of stack.
 Data Structures Using C

3. PEEK operation displays the top element of stack.

♣ Underflow Condition – Checking whether the stack is empty
♣ Overflow Condition – Checking whether the stack is full (i.e.) number of elements in stack is
equal to its size.

For example, the elements going to be added in stack are {5, 7, 9, 2, 10}
Order of PUSH = 5, 7, 9, 2, 10
Order of POP = 10, 2, 9, 7, 5

3.3 IMPLEMENTATION OF STACK ADT

For the representation of Stack ADT, two basic data structures are used,
1. Using Array data structure
2. Using Linked List data structure

3.3.1 USING ARRAY DATA STRUCTURE

♣ One of the simplest ways of representing a stack is by means of a “single dimensional
array”.
♣ Array data structure stores fixed number of elements depending on its declaration. The
size of stack can be varied within the space reserved for it. So we declare the array whose
size is “equal to” stack size.
♣ One end of the array is fixed & the other end (i.e. top of stack) becomes constantly
changed depending upon the elements pushed to or popped from the stack.
♣ Care must be taken in handling extreme cases that are don’t PUSH an element onto the
Fully Occupied Stack (there is no storage space in stack to perform insert) and don’t
POP an element from the Empty Stack (there is no more element present in the stack).

Implementation of PUSH & POP operations of Stack ADT is similar to Insert Last &
Delete Last operation in List ADT using Array data structure. Instead of using “N” to
Note: indicate the end of List in List ADT, “Top” variable is used in Stack.

1. PUSH

Algorithm
Step-1: Check whether the stack is full or not (i.e.) overflow condition of stack. If yes
terminate else do next.
Step-2: Get the element from the user and increment the top variable by 1.
Step-3: Insert an element onto the array of top variable.
 Data Structures Using C

2. POP

Algorithm
Step-1: Check whether the stack is empty or not (i.e.) “Under flow condition of stack”. If
yes then terminate else do next.
Step-2: Decrement the top pointer by one.

IMPLEMENTATION IN C
#include<stdio.h>
#include<conio.h>
#define SIZE 5
int stack[SIZE],top=-1;
void main()
{
int choice;
void push();
void pop();
void peek();
int isempty();
int length();
void display();
clrscr();
while(1)
{
printf("\n1.PUSH\n2.POP\n3.Display\n4.Length\n5.Peek\n6.Quit\nEnter U'r choice?\n");
scanf("%d",&choice);
switch(choice)
{
case 1:
push();
break;
case 2:
pop();
 Data Structures Using C

break;
case 3:
display();
break;
case 4:
printf("Number of Elements in the Stack is:%d\n",length());
break;
case 5:
peek();
break;
case 6:
exit(0);
break;
default:
printf("Invalid Choice\n");
}
}
}

void display()
{
int i,temp=top;
if(isempty())
{
printf("\n Stack Empty\n");
return;
}
printf("\n Elements in the Stack \n");
for(i=temp;i>=0;i--)
printf("%d\t",stack[i]);
}

void push()
{
int no;
if(top==SIZE-1)
printf("Stack is Full\n");
else
{
printf("Enter the Number\n");
scanf("%d",&no);
top++;
stack[top]=no;
display();
}
 Data Structures Using C

void pop()
{
int no;
if(isempty())
{
printf("Stack is Empty\n");
top=-1;
}
else
{
no=stack[top];
printf(" %d is popped from the stack\n",no);
--top;
display();
}
}

void peek()
{
if(isempty())
{
printf("\n Stack Empty\n");
return;
}
printf("The peek value of the Stack is %d\n",stack[top]);
}

int isempty()
{
return(top==-1);
}

int length()
{
return(top+1);
}

Sample I/O
1.PUSH
2.POP
3.Display
4.Length
5.Peek
 Data Structures Using C

6.Quit
Enter U'r choice?
1
Enter the Number
10
The element 10 is pushed onto the stack

Enter U'r choice?

1
Enter the Number
20
The element 20 is pushed onto the stack

Enter U'r choice?

3
Elements in the Stack
20 10

Enter U'r choice?

5
The peek value of the Stack is 20

Enter U'r choice?

4
Number of Elements in the Stack is:2

Enter U'r choice?

2
20 is popped from the stack

3.3.2. USING LINKED LIST DATA STRUCTURE

♣ It is another way to implement the stack concept. It has several advantages over Array
representation. Here stack size is variable due to the use of dynamic memory allocation.
♣ When we perform POP operation, unnecessary shifting of elements will be avoided by
using linked list data structure.
♣ One end of the linked list is fixed & the other end (i.e. top of stack) becomes constantly
changed depending upon the elements pushed to or popped from the stack.
♣ Care must be taken in handling extreme cases (i.e.) don’t POP an element from the
Empty Stack.
♣ Consider the Head pointer as a top of stack in linked list (i.e.) insertion and deletion
operations are carried out based on this top pointer only.

1. PUSH
 Data Structures Using C

Algorithm
Step-1: Create a node by using malloc( ) library function.
Step-2: Get the data value from user and assign it to the data field of new node and also
assign NULL to link field of new node.
Step-3: Assign the value of top to the link field of new node and also assign the newnode
address to the top.

4
3
2 42
1 66
0 35
4
3 30
2 42
1 66 Implementation of PUSH & POP operations of Stack ADT is similar to Insert
0 35 First & Delete First operation in List ADT using Linked list data structure.
4 Instead of using “Head” to indicate Start of List in List ADT, “Top” Pointer is
3 used in Stack.
2 42
1 66
0 35
4
3
2
1 66
0 35

Note:
 Data Structures Using C

void push( )
{
create_node();
newnode->next=top;
top=newnode;
printf("The Element %d is pushed onto the Stack\n",newnode->no);
}

2. POP

Algorithm
Step-1: Check the top is NULL or not. If NULL then give user message as “stack is
empty”, else do next.
Step-2: Assign next field of top pointer to the top pointer.

void pop( )
{
temp=top;
if(top==NULL)
printf("Empty Stack\n");
else
{
top=top->next;
printf("Element %d is popped from the Stack",temp->no);
free(temp);
}
}

Let us consider Insert last & Delete last operations of List ADT are the equivalent
operations to PUSH & POP operation of Stack ADT. It is not efficient because if the
last node of linked list is known in advance, then only it is possible to perform insert
 Data Structures Using C

Note: last & delete last operations in less time. But search operation is not efficient in Linked
list. So that only we perform “Insert first” as PUSH and “Delete first” as a POP
operation in Stack ADT using linked list.

IMPLEMENTATION IN C
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct node
{
int no;
struct node*next;
}*temp,*newnode,*top=NULL;

typedef struct node s;

void main()
{
void create_node();
void push();
void pop();
void display();
void peek();
int length();
int choice;
clrscr();
while(1)
{
printf("\n1.PUSH\n2.POP\n3.Peek\n4.Display\n5.Length\n6.Quit\nEnter U'r Choice?\n");
scanf("%d",&choice);
switch(choice)
{
case 1:
push();
break;
case 2:
pop();
break;
case 3:
peek();
break;
case 4:
display();
 Data Structures Using C

break;
case 5:
printf("The Length of the Stack is: %d\n",length());
break;
case 6:
exit(0);
default:
printf("Invalid Choice\n");
}
}
}

void create_node()
{
newnode=(s *)malloc(sizeof(s));
printf("Enter the Number\n");
scanf("%d",&newnode->no);
newnode->next=NULL;
}

void push()
{
create_node();
newnode->next=top;
top=newnode;
printf("The Element %d is pushed onto the Stack\n",newnode->no);
}

void pop()
{
temp=top;
if(top==NULL)
printf("Empty Stack\n");
else
{
top=top->next;
printf("Element %d is popped from the Stack",temp->no);
free(temp);
}
}

void peek()
{
if(top==NULL)
printf("Empty Stack\n");
 Data Structures Using C

else
printf("The peek value of stack is: %d",top->no);
}

void display()
{
if(top==NULL)
printf("Stack is Empty\n");
else
{
temp=top;
printf("The elements present in the stack :\n");
while(temp!=NULL)
{
printf("%d\t",temp->no);
temp=temp->next;
}
}
}

int length()
{
int cnt=0;
temp=top;
while(temp!=NULL)
{
++cnt;
temp=temp->next;
}
return cnt;
}

Sample I/O
1.PUSH
2.POP
3.Peek
4.Display
5.Length
6.Quit
Enter U'r Choice? 1
Enter the Number
10
The Element 10 is pushed onto the Stack
Enter U'r Choice? 1
Enter the Number
 Data Structures Using C

20
The Element 20 is pushed onto the Stack
Enter U'r Choice? 1
Enter the Number
30
The Element 30 is pushed onto the Stack
Enter U'r Choice? 3
The peek value of stack is: 30
Enter U'r Choice? 5
The Length of the Stack is: 3
Enter U'r Choice? 2
Element 30 is popped from the Stack
Enter U'r Choice? 4
The elements present in the stack :
20 10

3.4. APPLICATIONS OF STACK ADT

1. Tower of Hanoi
2. Reverse a string
3. Balanced parenthesis (or) Balancing symbol
4. Conversion from infix expression to postfix expression
5. Evaluation of postfix expression
6. Function calls

3.4.1. TOWER OF HANOI

♣ It is a game which contains three Shafts named as A, B and C.
♣ Based on risk levels, minimum to maximum number of Disc will be placed on the
Shaft A.
♣ Discs are varying in size from large to small (i.e.) small disc is placed above the large
one.
♣ The goal is to transfer the Discs from Shaft A to Shaft C using the Shaft B.
♣ The constraints to play the game are,
1. Only one Disc should be moved at a time.
2. No larger Disc should be placed above the smaller one while moving discs.
3. Top Disc in shaft should be removed first.

In this game, a last inserted disc in a shaft should be removed first (i.e.) logic of Stack
ADT. Here each shaft will become a stack and push and pop operation will be carried out when
discs are moved from or to the shaft.

For example, consider ‘N’ is number of disc placed in Shaft A which decides the game level.

When N=1
 Data Structures Using C

When N=2,

IMPLEMENTATION IN C
#include<stdio.h>
void hanoitowers(int,char,char,char);
void hanoitowers(int n, char peg1, char peg2, char peg3)
{
if(n==1)
{
printf("\nMove disk 1 from peg %c to peg %c",peg1,peg2);
return;
}
hanoitowers(n-1,peg1,peg3,peg2);
printf("\nMove disk %d from peg %c to peg %c",n,peg1,peg2);
hanoitowers(n-1,peg3,peg2,peg1);
}

void main( )
{
int n;
printf("Enter the number of disks : ");
scanf("%d",&n);
printf("The Tower of Hanoi involves the moves :\n\n");
hanoitowers(n,'A','C','B');
return 0;
}
 Data Structures Using C

3.4.2. REVERSE A STRING

It is very simple to implement the reverse a string process using stack ADT. To reverse a
string, make an empty stack. Push each character of input string to the stack until end of the
string. After that, pop each character from the stack and write it to output until stack becomes
empty. Now the string will become reversed.

For example, consider an input string “RICE”.

Therefore the result of reverse a string “RICE” is “ECIR”.

3.4.3. BALANCING SYMBOLS

♣ Compiler checks the program for syntax errors, but frequently a lack of one symbol (such
as missing brace or comment starter) will cause the compiler to spill out a hundred lines
of diagnostics without identifying the real error.
♣ Here a program checks whether everything is balanced or not. Thus every right brace,
bracket, and parenthesis must correspond to its left counterpart. The sequence [( )] is
legal, but the sequence [( ]) is wrong.
♣ A simple algorithm will just check for balancing of parenthesis, bracket and braces and
ignore any other character that appears using Stack ADT.
 Data Structures Using C

Algorithm
Step-1: Make an empty stack. Read the character one by one until the end of expression or
file.
Step-2: If the character is an opening symbol then push it onto the stack.
Step-3: If it is a closing symbol, Check the stack is empty or not. If empty then report an
error.
Step-4: Otherwise, pop the stack. If the popped symbol is not matched with the
corresponding closing symbol, then report an error.
Step-5: At end of file, if the stack is not empty then report an error.

For example, Consider the expression (X + Y)) + Z

Therefore the given input expression is not valid or balanced expression.

IMPLEMENTATION IN C
#include<stdio.h>
#include<conio.h>
#include<string.h>
#define valid 1
#define invalid 0
#define stack_size 9
int isempty();
int isfull();
int push(int val);
int pop(int *ptr);
int checkBalance(char expre[stack_size],int expr_len);
int top=-1,char stack[stack_size];

void main()
{
 Data Structures Using C

int status;
char expr[stack_size];
clrscr();
printf("\n Enter the expression:\n");
gets(expr);
printf("%s\t%d\n",expr,strlen(expr));
status=checkBalance(expr,strlen(expr));
printf("%d\n",status);
printf("\n Expression is %s",(status)?"valid":"Invalid");
getch();
}

int push(int val)

{
if(isfull())
return -1;
stack[++top]=val;
return 0;
}

int pop(int *ptr)

{
if(isempty())
return -1;
*ptr=stack[top--];
return 0;
}

int isempty()
{
return(top==-1);
}

int isfull()
{
return(top==stack_size-1);
}

int checkBalance(char expre[stack_size],int len_expr)

{
int i,j,item,nop=3;
char open_braces[]={'[','{','('};
char close_braces[]={']','}',')'};
for(i=0;i<len_expr;i++)
{
 Data Structures Using C

for(j=0;j<nop;j++)
{
if(expre[i]==open_braces[j])
if(push(expre[i])==-1)
return invalid;
else if(expre[i]==close_braces[j])
if(pop(&item)==-1 ||open_braces[j]!=item)
return invalid;
}
}
if(!isempty())
return invalid;
return valid;
}

Sample I/O 1:

Enter the expression:

(a+b)
The given expression is (a+b) and length=5
Expression is valid

Sample I/O 2:

Enter the expression:

((a+b)
The given expression is ((a+b) and length=6
Expression is Invalid

Sample I/O 3:

Enter the expression:

(a+b))
The given expression is (a+b)) and length=6
Expression is Invalid

3.4.4. CONVERSION FROM INFIX EXPRESSION TO POSTFIX EXPRESSION

Notation Arithmetic Expression Example

Infix Operand1 (Operator) Operand2 A+B
 Data Structures Using C

Prefix (Polish Notation) (Operator) Operand1 Operand2 +AB

Postfix (Reverse Polish Notation) Operand1 Operand2 (Operator) AB+

Advantages of Postfix expression

♣ Don’t worry about the rules of Operator Precedence.
♣ Don’t worry about the rules for Right to Left Associativity.
♣ Need not be specify the parenthesis to override the above rules.

CONVERSION PROCEDURE WITHOUT USING STACK ADT

For large expression, it takes long time to convert and sometimes it leads to confusion
because of assigning and substituting temporary variables in the conversion process.

Example 1: consider the Infix expression (x+y)*z

=> (xy+)*z
=> A*z (where A = xy+ & remove the parenthesis)
=> Az* Substitute A
=> xy+z* (postfix notation)

Postfix expression should not contain the parenthesis.

Note:

Example 2: consider the Infix expression a+b*c+(d*e+f)*g

=> a+b*c+(de*+f)*g
=> a+b*c+(A+f)*g where A=de*,
=> a+b*c+(Af+)*g
=> a+b*c+B*g B=Af+
=> a+bc*+Bg*
=> a+C+D C=bc* and D=Bg*
=> (aC+)+D
=> E+D E=aC+
=> ED+ Substitue E & D
=> aC+Bg*+ Substitue B
=> aC+Af+g*+ Substitue A & C
=> abc*+de*f+g*+ (postfix)

CONVERSION PROCEDURE USING STACK ADT

Algorithm
Step-1: Make an empty stack and output file.
Step-2: Read the input expression or file until it reaches the end.
Step-3: When an Operand is read, it will be placed onto the output.
 Data Structures Using C

Step-4: When a left parenthesis is read, PUSH onto the stack.

Step-5: When a right parenthesis is read, POP the elements from the stack one
by one and write it in output up to the occurrence of left parenthesis. But don’t
write these left and right parentheses onto the output.
Step-6: When an operator is read (like + , - , * , /) check the stack is empty or not. If
empty, then PUSH the operator onto the stack.
Step-7: If stack not empty then PEEK the element from the stack and check the
precedence of it. If it is higher or equal to the precedence of the operator read from
input then POP the operator from the stack and write it in output. Repeat this step
until the peeked operator from stack has higher precedence than the read operator
from input. Otherwise do next.
Step-8: If the Peeked operator has less precedence, then PUSH the read
operator onto the stack.
Step-9: When it reaches the end of input, if the stack is not empty then pop the
elements from stack and write it onto the output until stack becomes empty.

For example, consider the Infix expression a+b*c+(d*e+f)*g

Data Structures Using C
 Data Structures Using C

Therefore the result of postfix expression is abc*+de+f+g*+

IMPLEMENTATION IN C
#include<stdio.h>
#include<conio.h>
char post_fix[20];

int input_precede(char sym)

{
switch(sym)
{
case '+ :
return 1;
case '-' :
return 1;
case '*':
return 3;
case '/' :
return 3;
case '%':
return 3;
case '^':
return 6;
case '$':
return 6;
case '(':
return 9;
case ')':
return 0;
default:
return 8;
}
}

int stack_precede(char sym)

{
switch(sym)
{
 Data Structures Using C

case '+':
return 2;
case '-':
return 2;
case '*':
return 4;
case '/':
return 4;
case '%':
return 4;
case '^':
return 5;
case '$':
return 5;
case '(':
return 0;
case '#':
return -1;
default:
return 8;
}
}

void in_to_post(char inf[20])

{
char st[20],s;
int i,j=0,top=-1;
st[++top]='#';
for(i=0;inf[i]!='\0';i++)
{
s=inf[i];
while(stack_precede(st[top])>input_precede(s))
post_fix[j++]=st[top--];
if(stack_precede(st[top])!=input_precede(s))
st[++top]=s;
else
top--;
}
while(st[top]!='#')
{
post_fix[j++]=st[top--];
}
post_fix[j]='\0';
printf("\nPostfix : %s\n",post_fix);
}
 Data Structures Using C

int main( )
{
char infix[25];
clrscr();
printf("\nEnter a valid infix expression:\n");
gets(infix);
in_to_post(infix);
getch();
return 0;
}

3.4.5. EVALUATION OF POSTFIX EXPRESSION

Algorithm
Step-1: Make an empty stack & Read the element one by one until the end of input.
Step-2: If it is an operand then PUSH onto the stack.
Step-3: If it is an operator then POP the element twice from the stack and perform the
manipulation on it also PUSH the result of manipulation on to the stack.
Step-4: When end of expression is reached, POP the element from stack and write it to
output.

For example, consider the Postfix expression 6 5 2 3 + 8 * + 3 + *

 Data Structures Using C

Thus the result of evaluation of postfix expression is 288.

IMPLEMENTATION IN C
#include<stdio.h>
#include<conio.h>

struct node
{
int data;
struct node *next;
}*top=NULL,*temp=NULL,*newnode=NULL;

void createnode(int val)

{
newnode=(struct node *)malloc(sizeof(struct node));
newnode->data=val;
newnode->next=NULL;
}
 Data Structures Using C

void stk_push(int val)

{
createnode(val);
newnode->next=top;
top=newnode;
}

int stk_pop()
{
int val=0;
if(top==NULL)
printf("Stack Empty\n");
else
{
val=top->data;
top=top->next;
}
return val;
}

void main()
{
char str[50],choice;
int i,a,b;
clrscr();
printf("Enter the Postfix expree to evaluate\n");
gets(str);
for(i=0;i<strlen(str);i++)
{
choice=str[i];
switch(choice)
{
case '+':
printf("perform the operation +\n");
b=stk_pop();
a=stk_pop();
printf("Push the value %d into stack\n",a+b);
stk_push(a+b);
break;
case '-':
printf("perform the operation -\n");
b=stk_pop();
a=stk_pop();
printf("Push the value %d into stack\n",a-b);
 Data Structures Using C

stk_push(a-b);
break;
case '*':
printf("perform the operation *\n");
b=stk_pop();
a=stk_pop();
printf("Push the value %d into stack\n",a*b);
stk_push(a*b);
break;
case '/':
printf("perform the operation /\n");
b=stk_pop();
a=stk_pop();
printf("Push the value %d into stack\n",a/b);
stk_push(a/b);
break;
default:
printf("Push the value %d into stack\n",atoi(&choice));
stk_push(atoi(&choice));
break;
}
}
printf("%d is the answer for ",top->data);
printf("the given postfix expression:");
puts(str);
getch();
}

3.4.6. FUNCTION CALLS

♣ When a call is made to a new function,

1. All the variables local to the Caller routine must be saved by the system,
since the Called function will overwrite the Caller routine variables.
2. Furthermore the current location of Caller routine must be saved, so that the
Called function knows where to go after it completes the process.
♣ This process is similar to balancing the symbols. A function call & function return are
essentially the same as that of open parenthesis & closed parenthesis. Therefore the same
idea should work also here.
♣ When there is a function call, all the important information that needs to be saved, such
as register value (the variables have generally been assigned by the compiler to machine
register) and the return address (which can be obtained from the program counter) is
saved and put at the top of a Pile or Stack. Then the control is transferred to the Called
function. Those saved information will be called as Activation record or Stack frame.
 Data Structures Using C

♣ When the function completes its execution then it looks at the top of Pile and restores all
the registers. It then makes the return jump.
♣ Clearly, all of this work can be done by using a stack.
♣ In many systems there is no checking for the stack overflow. There is a possibility to run
out of stack space by having too many simultaneously active functions. It is always a
fatal error.
♣ Consider the following routine, which prints out a linked list. It is perfectly legal & can
be proven correct. Unfortunately, if the list contain 20,000 activation records,
(representing the nested call of line 3) then this program is likely to run out of stack
space

Bad use of recursion

void PrintList (list L)
{
if(L!=NULL) --------------------------- Line 1
{
printf(“%d”,L->element);--------- Line 2
PrintList (L->next);---------------- Line 3
}
}

♣ This program is an example of an extremely bad use of recursion known as “Tail

recursion”.
♣ Tail recursion refers to a recursive call written at the last line of a function. It can be
mechanically eliminated by changing the recursive call to a “goto” statement preceded by
one assignment statement per function argument.

void PrintList(list L)
{
Top:
if(L!=NULL)
{
printf(“%d”, L->element);
L=L->next;
}
goto Top;
}

♣ This simulates the recursive call as a local function so nothing needs to be saved. The
“goto” statement is used here to show how a compiler might automatically remove the
recursion.
♣ Removal of tail recursion is simple so that some compilers are doing it automatically.
 Data Structures Using C

QUEUE ADT

4.1 INTRODUCTION
Let us consider five persons are waiting in a line, in front of a ticket counter for buying
tickets. The person who is standing in front of the line will get the first ticket. Second person will
get the next ticket, and so on. If a new person wants to buy a ticket then he should stand after the
last person in a queue. These similar operations are carried out in a queue of DS.

♣ Queue ADT has an ordered collection of element in which insertion is made at one end of
list & deletion is made at the other end.
♣ The queue has two ends. The end at which insertions are made is referred to as the
“REAR” end. The end from which deletions are made is referred to as the “FRONT”
end.
♣ Front end points the first element in queue which is going to be deleted first. Rear end
points the last element in queue and used to insert a new element onto to the queue.
♣ The first element placed in a queue will be at the start of queue. The last element placed
in a queue will be at the last of the queue.
♣ Capacity of queue or Queue size determines the storage of number of element onto the
queue.
 Data Structures Using C

♣ In queue, the first inserted element will be removed first. So a queue is referred as
First-In-First-Out (FIFO) or LILO (Last-In-Last-Out) ADT.

♣ If the number of elements stored onto the queue is equal to the queue size then the queue
is called as “Fully Occupied Queue”. If there is no element in queue then it is called as
“Empty Queue”.

4.2 OPERATIONS ON QUEUE ADT

The primary operations that can be done on a queue are insertion & deletion. These
operations are referred as “Enqueue” and “Dequeue” respectively.
1. Enqueue – Insert a new element onto the queue.
2. Dequeue – Delete an element from the queue.

TYPES OF QUEUE ADT

1. Linear Queue
2. Circular Queue.
3. Deque Queue
4. Priority Queue.

4.3 LINEAR QUEUE

♣ It is a simple queue structure. In which traversal operation is carried out in only one
direction i.e. from front to rear.
♣ Linear queue is mostly implemented by using Array Data Structure.
♣ To keep track of first and last element of a queue for doing deletion and insertion
operations, two integer variables are needed which will be named as “front” and “rear”
variables respectively.
♣ Initially the front & rear variables are at the same position (i.e. initialized as ‘-1’ because
‘0’ becomes a first index of Array DS).
♣ During the enqueue operation, the rear variable is incremented by one and new element is
placed on the rear position of queue. This will be repeated until it reaches the
Queue-Size, whereas front variable doesn’t change.
 Data Structures Using C

♣ Front is assigned as ‘0’ when the rear is one, because front should points the element
going to be deleted first from the queue.
♣ During the Dequeue operation, the front variable is incremented one by one until all the
elements of a queue will be deleted.
♣ When the front variables value is larger than rear then both are reinitialized as minus one
i.e. queue is said to be empty.
♣ In linear queue, the Enqueue operation is performed irrespective of the position of front
variable that is after the deletion of some elements from the queue, it won’t be fully
occupied queue but we can’t perform Enqueue of new element onto the queue. So the
Queue size is not properly utilized i.e. memory is wasted. This is the main drawback of
linear queue.

4.3.1 REPRESENTATION OF LINEAR QUEUE USING ARRAY

♣ Care must be taken in handling extreme cases, like not to insert an element into a fully
occupied queue and not to delete an element from an empty queue.
♣ The front & rear values are constantly changed depending upon the elements enqueued or
dequeued the queue.

1. ENQUEUE

Algorithm
Step-1: Check the queue is full or not (Rear < (Qsize – 1))
Step-2: Increment rear value by 1 and get the element from the user and store it in
the array of rear position.
Step-3: If the rear value is 0 then assign front as 0 because the front should points the
element going to be dequeued from the queue.

For example, consider a queue with size 6. Enqueue the element {14, 2}
 Data Structures Using C

IMPLEMENTATION IN C
#define SIZE 10
int Q[SIZE], front= -1, rear= -1;

void Enqueue( )
{
int no;
if(rear = = (SIZE-1) )
printf("Queue is Full\n");
else
{
printf("Enter the Number\n");
scanf("%d",&no);
++rear;
Q[rear]=no;
if(rear= =0)
front=0;
printf("The %d element is enqueued onto the queue\n",no);
}
}

2. DEQUEUE

Algorithm
Step-1: Check the queue is empty or not (front= = -1)
Step-2: Increment front value by 1.
Step-3: If the rear value is less than the front then assign -1 to rear and front
variable.
For example,
 Data Structures Using C

IMPLEMENTATION IN C
void Dequeue()
{
int no,i;
if(front= = -1)
{
printf("Queue is Empty\n");
}
else
{
no=Q[front];
++front;
if(rear>front)
front=rear=-1;
printf(" %d is removed from the Queue\n",no);
}
}
 Data Structures Using C

4.3.2 REPRESENTATION OF LINEAR QUEUE USING SINGLY LINKED LIST

1. NODE CREATION ALGORITHM

Step-1: Define a structure of a node using Structure DS.

Step-2: Allocate a dynamic memory by using malloc( ) library function with a specified
size of node.
Step-3: Read the data & assign it to the data field of a node. Also assign NULL value to
its link field

IMPLEMENTATION IN C
struct node // Skeleton of Node
{
int data;
struct node *next;
};

struct node * Front,* Rear,*prev,*temp,*newnode; //Structure Pointers

Front=NULL;
Rear=NULL;

void create_node( ) //Memory allocation and initialization of New Node

{
newnode=(struct node *)malloc(size of(struct node));
if (newnode= =NULL)
{
printf(“Memory is not allocated for a node\n”);
break;
}
else
{
printf(“Enter the data value\n”);
scanf(“%d”,&newnode->data);
newnode->next=NULL;
}
}

2. ENQUEUE

Algorithm
 Data Structures Using C

Step-1: Check the Front pointer is NULL or not (Queue Empty). If it is NULL then
assign newnode address to Front as well as Rear pointer, otherwise follow the next
steps.
Step-2: Call to create_node function.
Step-3: Assign new node address to the link field of Rear node and also to the Rear
node.

IMPLEMENTATION IN C
void Enqueue( )
{
if(Front= =NULL)
Front=Rear=newnode;
else
{
create_node();
Rear->next=newnode;
Rear=newnode;
}
}

3. DEQUEUE

Algorithm
Step-1: Check the Queue is empty or not. If empty then terminate the process, otherwise
assign the link field of first node (i.e. Front pointer) to the Front pointer.
Step-2: Freed the memory space of deleted node by using free( ) library function
 Data Structures Using C

IMPLEMENTATION IN C
void Dequeue( )
{
if(Front= =NULL)
printf(“Queue is empty\n”);
else
{
temp= Front;
Front = Front ->next;
free(temp);
}
}

Implementation of Enqueue & Dequeue operations of Queue ADT using

Linked list is similar to Insert Last & Delete First operation in List ADT using
Linked list data structure. Instead of using “Head” & “Tail” to indicate Start &
End of List in List ADT, here “Front” & “Rear” Pointers are used for
Note: performing Dequeue & Enqueue respectively in QUEUE.

4.4 CIRCULAR QUEUE

1 2

0 3

4
 Data Structures Using C

♣ It is a type of queue in which traversal can be performed in only one direction from front
to rear.
♣ It is same as linear queue except that the structure of queue becomes circularly
connected. So that, it overcomes the drawback of linear queue (i.e.) memory space of
dequeued element is also used for enqueue until the queue is full.
♣ Initially the front & rear pointer are at same position (i.e., (-1)). When you insert element,
the rear pointer is incremented by one and the new element is stored on the position [rear
% Qsize] where % is a modular operation. So that, enqueue operation is carried out until
the queue is full.
♣ Front is assigned to ‘0’ when the rear is equal to one, because front should points the
element going to be deleted first from the queue.
♣ The queue is said to be fully occupied when difference of rear and front is equal to the
queue size minus one (rear-front= =Qsize-1). When rear or front has a value -1, the queue
is said to be empty queue (front= =-1).
♣ When the front value is greater than the rear then both are reinitialized as -1 i.e. queue
becomes empty.

4.4.1 REPRESENTATION OF CIRCULAR QUEUE USING ARRAY

♣ Care must be taken in handling extreme cases, like not to insert an element into a fully
occupied queue and not to delete an element from an empty queue. secretary
♣ The front & rear values are constantly changed depending upon the elements enqueued or
dequeued the queue.

1. ENQUEUE

Algorithm
Step-1: Check the queue is full or not (Rear-Front = = (Qsize – 1))
Step-2: Get the element from the user and Increment the rear value by 1.
Step-3: Store the input to the array of [rear mod (Qsize-1)] position.
Step-4: If the rear value is 0 then assign front as 0 because the front should points the
element going to be dequeued from the queue.

IMPLEMENTATION IN C
 Data Structures Using C

#define SIZE 10
int Q[SIZE], front= -1, rear= -1;

void Enqueue( )
{
int no;
if((rear-front) = = (SIZE-1) )
printf("Queue is Full\n");
else
{
printf("Enter the Number\n");
scanf("%d",&no);
++rear;
Q[rear % SIZE]=no;
if(rear= =0)
front=0;
printf("The %d element is enqueued onto the queue\n",no);
}
}

2. DEQUEUE

Algorithm
Step-1: Check the queue is empty or not (front= = -1)
Step-2: Increment front value by 1.
Step-3: If the rear value is less than the front then assign -1 to rear and front
variable.

IMPLEMENTATION IN C
void Dequeue()
{
int no,i;
if(front= = -1)
{
printf("Queue is Empty\n");
}
else
{
no=Q[front % SIZE];
++front;
if(rear>front)
front=rear=-1;
printf(" %d is removed from the Queue\n",no);
}
 Data Structures Using C

For example, consider a circular queue with size 4. Enqueue the elements {14, 2, 5, 6}.
After that Dequeue 2 elements from queue and Enqueue the element {9}.

0 1

3 2

14

14 2

14 2
 Data Structures Using C

14 2

6 5

6 5

6 5
 Data Structures Using C

6 5

4.4.2 REPRESENTATION OF CIRCULAR QUEUE USING CSLL

1. ENQUEUE

IMPLEMENTATION IN C
 Data Structures Using C

void Enqueue( )
{
create_node( );
if(Front= =NULL)
Front=Rear=newnode;
else
{
Rear ->next=newnode;
Rear =newnode;
newnode->next=Front;
}
newnode->next=Front;
}

2. DEQUEUE

IMPLEMENTATION IN C
void Dequeue( )
{
if(Front= =NULL)
printf(“Queue is empty\n”);
else
{
temp=Front;
if(Front->next= = Front)
{
Front=NULL;
free(temp);
}
 Data Structures Using C

else
{
Front = Front->next;
free(temp);
Rear->next= Front;
}
}
}

Implementation of Enqueue & Dequeue operations of Circular Queue ADT

using Circular Linked list is similar to Insert Last & Delete First operation in
List ADT using Linked list data structure. Instead of using “Head” & “Tail” to
Note: indicate Start & End of List in List ADT, here “Front” & “Rear” Pointers are
used for performing Dequeue & Enqueue respectively in QUEUE.

4.5 DEQUE QUEUE

It is another form of queue in which insertion & deletion are made at both end (the front
& rear) of the queue. It is also referred as Double ended queue. There are 2 variation of deque,
namely input restricted deque and output restricted deque.

1. Input Restricted Deque - Allow insertion at only one end and deletion in both end of
queue.
2. Output Restricted Deque - Allow deletion at only one end and insertion in both end of
queue.

The possible operation performed on deque is:

1. Add an element at the rear end
 Data Structures Using C

2. Add an element at the front end

3. Delete an element at the rear end
4. Delete an element at the front end

Only 1st, 3rd & 4th operations are performed by the input-restricted deque and 1st, 2nd, & 4th
operations are performed by the output-restricted deque.

4.6 PRIORITY QUEUE

It is a collection of elements and each element contains a key referred as priority. Element
can be inserted in any order (i.e. elements are placed onto the queue in alternating priority). The
element are deleted from the queue only based on the order of their priority (i.e., the element
with higher priority is deleted first and so on). The elements having same priority are consider
being equal importance & processed accordingly.
For example, consider a queue at your library, when a professor likes to borrow a book
from library, he/she may not be asked to stand in the queue. Normally, we allow him to the front
of the queue.

TYPES OF PRIORITY QUEUE

1. Ascending priority queue – elements can be inserted arbitrarily but an element with small
priority will be deleted first from the queue.
2. Descending priority queue - elements can be inserted arbitrarily but an element with large
priority will be deleted first from the queue.

IMPLEMENTATION OF PRIORITY QUEUE

1. Using Array Data structure
One of the simplest ways to implement a priority queue is by using an array data
structure. But it has the following demerits.

♣ Using Unordered Array- Inserting an element is easy as it could be done at the

last available entry. Hence insertion takes O(1) time. To remove the highest
priority element, we need to search the higher priority element in the entire
array. Hence deletion takes O(n) time (where n is a number of element in
queue). Since we frequently remove the data, this implementation is not
preferred.

♣ Using Ordered Array - Insert an element into an ordered list takes O(n) time
(i.e. we have to traverse the list to find where the element is actually inserted
based on its priority). Deletion of the maximum element takes only O(1) time
because of ordered list. Since we frequently insert the data, this implementation
is not preferred.

2. Using Heap Data structure

As in real application of priority queues, both insertion & deletion are frequent. We need
both operations to be faster. By using heap data structure, both insertion & deletion operation
 Data Structures Using C

takes only O(log n) time to complete the process. Heap is type of TREE ADT. This will be
elaborately discussed in the chapter of Balanced Trees ADT.

4.7 COMPARISON OF LINEAR QUEUE & CIRCULAR QUEUE

Queue Type Using Array Data Using Linked list data

Structure structure
Fully Linear Queue Rear value is equal to the When the node is not create
occupied (Qsize-1) (i.e., total no. of properly by malloc( ) i.e. it
queue element in the queue is equal return NULL value then it
to Qsize) means that the queue is full
Circular Queue (Rear-Front) value is equal to Same as Linear Queue
the (Qsize-1)

Empty Linear Queue Rear=front=-1(i.e. there is no If front pointer is equal to

queue element present in the queue) NULL then the queue
becomes empty
Circular Queue Same as Linear Queue Same as Linear Queue.

Enqueue Linear Queue After increment the rear A new node is inserted at
value by one, the new last of linked list using rear
element is placed at the rearth pointer
index in array

Circular Queue After increment the rear Same as Linear Queue but
value by one, the new here the last node is
element is placed at the (rear circularly connected with
% Qsize)th index in array the first node.

4.8 APPLICATIONS OF QUEUE ADT

♣ There are several algorithms that use queue data structures to give efficient running
times. Example: Graph theory.
♣ When jobs are submitted to a networked printer, they are arranged in order of arrival, so
jobs are placed on a queue only.
♣ Virtually every real-life line is a queue. For example, line at ticket counters are queue,
because service is based on first come-first-served.
♣ There are many networks setup of personal computers in which the disk is attached to
one machine, known as the “file server”. Users on the other machines are given across to
files on a FCFS basics (i.e.) queue.
♣ Calls to large companies are generally placed on a queue when all operators are busy. For
example, jobs in Business Process Outsourcing.
 Data Structures Using C

♣ In large universities, resources are almost limited. A student must sign a waiting list if all
terminals are occupied. According to the waiting list order the service or terminals are
allocated to a student.
♣ Queue is used for BFS implementation to traverse a graph.
♣ Round-robin processor scheduling algorithm is implemented by using queue data
structure.

4.9 DIFFERENCE BETWEEN STACK & QUEUE ADT

Stack ADT Queue ADT

1. It is an ordered list where insertion and 1. It is an ordered collection of element
deletion operation are performed at one where insertion operation is performed at
end called Top of stack. rear end and deletion operation is
performed at front end of queue.
2. Stack is based on LIFO logic. 2. Queue is based on FIFO logic.
3. Associated with stack there is one 3. Associated with queue there are two
variable called Top. variable named as front and rear.
4. Insertion & deletion operations are
4. Insertion and deletion operations are referred as Enqueue & Dequeue
referred as PUSH & POP respectively. respectively.
5. Fully occupied stack can be identified by 5. Fully occupied queue is identified by rear
Top = =Stacksize-1 = = Qsize-1
6. To insert an element Top is incremented 6. To insert an element rear is incremented
by one. by one.
7. To delete an element Top is decremented 7. To delete an element front is incremented
by one. by one.