Data Structures

Unit-1
Syllabus
 Unit-I: Data Structures, Stacks , Queues

 Unit-II: Trees

 Unit-III:Advanced Concepts in Tree

 Unit-IV:Graphs

 Unit-V:Hashing
Text Books:
 1. Data Structures Using C, Second Edition Reema Thereja
OXFORD higher Education
 2. Data Structures, A Pseudo code Approach with C, Richard
F.Gillberg & Behrouz A. Forouzan, Cengage Learning, India
Edition, Second Edition, 2005.
 Course Outcomes:
 At the end of the course student would be able to
 1. Understand the concepts of Stacks and Queues with their
applications.
 2. Analyze Various operations on Binary trees.
 3. Examine of various concepts of binary trees with real time
applications.
 4. Analyze the shortest path algorithm on graph data
structures.
 5. Outline the concepts of hashing, collision and its resolution
methods using hash functions
 Unit-1 Data Structure
 Data structure is a representation of data and the operations
allowed on that data

 A data structure is a way to store and organize data in order

to facilitate the access and modifications

 A data structure is a special way of organizing and

storing data in a computer so that it can be used efficiently.
 Advantages of DS
 Data Organization: Organizing the data so that it can
accessed efficiently when we need that particular data.
 It is secure way of storage of data.
 It allows information stored on disk very efficiently
 Data Structure Types
There are two types of data structures:
 1. Linear Data Structure
2. Non-linear Data Structure
 Linear data structures: Elements of Linear data structure are
accessed in a sequential manner, however the elements can be stored
in these data structure in any order.
 Eg:LinkedList, Stack, Queue and Array

 Non-linear data structures: Elements of non-linear data

structures are stores and accessed in non-linear order.
 Eg:Tree and Graph
Classification of DS
Representation of Data Structure
 We can represent DS in Two ways:
 1. Static Representation
 2. Dynamic Representation
Static Representation:
In Static data structure the size of the structure is fixed. The
content of the data structure can be modified but without
changing the memory space allocated to it.
Example of Static Data Structures: Array
Representation of Data Structure
 Dynamic Representation:
 In Dynamic data structure the size of the structure in not
fixed and can be modified during the operations performed
on it.
 Dynamic data structures are designed to facilitate change of
data structures in the run time.
 Example of Dynamic Data Structures: Linked List
 Linked List
 A linked list is a linear data structure, in which the elements are
not stored at contiguous memory locations.

Why Linked List?

Arrays can be used to store linear data of similar types, but arrays have the following
limitations.
1) The size of the arrays is fixed: So we must know the upper limit on the number of
elements in advance. Also, generally, the allocated memory is equal to the upper limit
irrespective of the usage.

2) Inserting a new element in an array of elements is expensive because the room has to
be created for the new elements and to create room existing elements have to be shifted.
 Linked List
 Advantages over arrays
1) Dynamic size
2) Ease of insertion/deletion
 Drawbacks of Linked list:
1) Random access is not allowed. We have to access elements
sequentially starting from the first node. So we cannot do binary
search with linked lists efficiently with its default implementation.
2) Extra memory space for a pointer is required with each element
of the list.
3) Not cache friendly. Since array elements are contiguous locations,
there is locality of reference which is not there in case of linked lists.
 Linked List Representation
 A linked list is represented by a pointer to the first node of the linked list.
 The first node is called the head.
 If the linked list is empty, then the value of the head is NULL.
Each node in a list consists of at least two parts:
1) data
2) Pointer (Or Reference) to the next node

 // A linked list node

struct Node
{
int data;
struct Node* next;
};
Types of Linked List

 Single linked List

 Double Linked List
 Circular Linked List
Basic Operations on Linked List
 Traversal: To traverse all the nodes one after another.
 Insertion: To add a node at the given position.
 Deletion: To delete a node.
 Searching: To search an element(s) by value.
Single Linked List
 A Singly-linked list is a collection of nodes linked together in
a sequential way where each node of the singly linked list
contains a data field and an address field that contains the
reference of the next node
 The structure of the node in the Singly Linked List is
Single Linked List
A single linked list consists of nodes where each node
contains a data field and a reference(link) to the next node in
the list.
Single Linked List
 The nodes are connected to each other in this form where
the value of the next variable of the last node is NULL
i.e. next = NULL, which indicates the end of the linked list.
Operations on SLL
 Insertion
 Insertion at the beginning
 Insertion at the end. (Append)
 Insertion after a given node
 Deletion
 Delete at the beginning
 Delete at the end.
 Delete a given node
 Search
 Search the node

 Traverse
 To traverse all the nodes one after another.
Insertion
 Insertion at the beginning:
 If the list is empty, the new node becomes the head of the
list. Otherwise, connect the new node to the current head of
the list and make the new node, the head of the list.
Insertion
 Insertion at end:
 Traverse the list until find the last node. Then insert the new
node to the end of the list.
 In case of a list being empty, return the updated head of the
linked list because in this case, the inserted node is the first as
well as the last node of the linked list.
 Insertion
 Insertion after a given node
 We are given the reference to a node, and the new node is
inserted after the given node.
Deletion
 Delete a beginning node:
 First node is pointed by the head, move the head to the next
node, then free the first node
 If there is only one node then free the node and head becomes
NULL
Deletion
 Delete the end node:
 Move the pointer to the last node and free the node.
 Keep the NULL in the before that node
 Deletion
 Delete a particular node
 To delete a node from linked list, do following steps.
1) Find previous node of the node to be deleted.
2) Change the next of previous node.
3) Free memory for the node to be deleted.
 Search
 To search any value in the linked list, traverse the linked list
and compares the value present in the node.

Traverse
•To traverse all the nodes one after another.
•Start with the head of the list. Access the content of the head node
if it is not null.
•Then go to the next node(if exists) and access the node
information
•Continue until no more nodes (that is, you have reached the null
node)
 Double Linked List
 A Doubly Linked List contains an extra memory to store the
address of the previous node, together with the address of the
next node and data which are there in the singly linked list. So,
here we are storing the address of the next as well as the
previous nodes.
 Double Linked List
 The nodes are connected to each other in this form where
the first node has prev = NULL and the last node has next
= NULL.

•Advantages over Singly Linked List-

•It can be traversed both forward and backward direction.
•Disadvantages over Singly Linked List-
•It will require more space as each node has an extra memory to store the
address of the previous node.
•The number of modification increase while doing various operations like
insertion, deletion, etc.
Double Linked List
 Insertion
A node can be added in four ways
1) At the front of the DLL
2) After a given node.
3) At the end of the DLL
4) Before a given node.
 Insertion in DLL
 At the front of the DLL:
 The new node is always added before the head of the given
Linked List. And newly added node becomes the new head of
DLL.
Insertion in DLL
 At the end of the DLL:
 A Linked List is typically represented by the head of it, we
have to traverse the list till end and then change the next of
last node to new node.
 Insertion in DLL
 Add a node after a given node:
 We are given pointer to a node as prevnode, and the new node
is inserted after the given node.
 Insertion in DLL
 Add a node before a given node:
 We are given pointer to a node as prevnode, and the new node is
inserted after the before given node.
Double linked list
 Deletion
 Delete the front node
 Delete the end node
 Delete the given node
Deletion in DLL
 Delete a First node:
 If the node to be deleted is the head node then make the next
node as head

After deleting the first node the linked list becomes:

 Deletion in DLL
 Deleting the last node:
Deletion in DLL
 Deleting a given node:
 Search
 To search any value in the linked list, traverse the linked list
and compares the value present in the node.

Traverse
•To traverse all the nodes one after another.
•Start with the head of the list. Access the content of the head node
if it is not null.
•Then go to the next node(if exists) and access the node
information
•Continue until no more nodes (that is, you have reached the null
node)
Circular Linked List
 Circular linked list is a linked list where all nodes are
connected to form a circle. There is no NULL at the end.
 A circular linked list can be a singly circular linked list or
doubly circular linked list.

Circular Single linked List

Circular Double linked List

Advantages of Circular Linked Lists:
1) Any node can be a starting point. We can traverse the whole
list by starting from any point. We just need to stop when the
first visited node is visited again.
2) Useful for implementation of queue. No need to maintain
two pointers for front and rear if we use circular linked list.
We can maintain a pointer to the last inserted node and front
can always be obtained as next of last.
3) Circular lists are useful in applications to repeatedly go
around the list.
Stacks
 Stack is a linear data structure which follows a particular
order in which the operations are performed. The order may
be LIFO(Last In First Out) or FILO(First In Last Out).
 Operations on Stack
 Elements can be inserted or deleted only from one end of the
stack i.e. from the top.
 The element at the top is called the top element.
 The operations of inserting and deleting elements are
called push() and pop() respectively.
Operations on Stack
 PUSH:
 Push operation refers to inserting an element in the stack.
 The new element is inserted at the top of the stack.

 POP:
 Pop operation Removes an element from the stack
 The top of the element is removed

 PEEK:
 Get the top data element of the stack, without removing it.
Implementation of Stack
 Stack can be implemented in two ways:
 1.Using Array
 2. Using Linked List
Array Implementation:
PUSH Operation:
 The size of the stack is specified at the beginning
 Initially stack is empty and top=-1
 When a new element is pushed it checks the condition whether
the stack is full,if it is true it gives “Overflow”
 Otherwise the element is inserted from top end
 Top variable is increased by 1
Array Implementation-PUSH
Step 1 - Check whether stack is FULL. (top == SIZE-1)
Step 2 - If it is FULL, then display "Stack is FULL!!! Insertion
is not possible!!!" and terminate the function.
Step 3 - If it is NOT FULL, then increment top value by one
(top++) and set stack[top] to value (stack[top] = value).
 Array Implementation-POP
 Pop():
 To delete an element from any , it checks whether the stack is
empty, if it is true it gives “Underflow”
 Otherwise top of the element is removed from the stack
 Top is decreased by 1
 If there are no more elements top will becomes -1
Pop
 Step 1 - Check whether stack is EMPTY. (top == -1)
 Step 2 - If it is EMPTY, then display "Stack is EMPTY!!!
Deletion is not possible!!!" and terminate the function.
 Step 3 - If it is NOT EMPTY, then delete stack[top] and
decrement top value by one (top--).
Display
 Step 1 - Check whether stack is EMPTY. (top == -1)
 Step 2 - If it is EMPTY, then display "Stack is EMPTY!!!" and
terminate the function.
 Step 3 - If it is NOT EMPTY, then define a variable 'i' and
initialize with top. Display stack[i] value and decrement i value
by one (i--).
 Step 3 - Repeat above step until i value becomes '0'.
Array Implementation-PEEK
 Peek:
 If the stack is empty it displays “ Stack is empty”
 Otherwise it displays the top of the element in the stack
Linked List Representation
 The main advantage of using linked list over an arrays is that
it is possible to implements a stack that can shrink or grow as
much as needed.
 In using array will put a restriction to the maximum capacity
of the array which can lead to stack overflow.
 Here each new node will be dynamically allocate.
 so overflow is not possible.
 The stack implemented using linked list can work for an
unlimited number of values.
Linked List Representation
 A stack can be easily implemented
through the linked list.
 In stack Implementation, a stack
contains a top pointer. which is “head”
of the stack where pushing and
popping items happens at the head of
the list.
 First node have null in link field and
second node link have first node
address in link field and so on and last
node address in “top” pointer.
PUSH
 Step 1 - Create a newNode with given value.
 Step 2 - Check whether stack is Empty (top == NULL)
 Step 3 - If it is Empty, then set newNode →
next = NULL.
 Step 4 - If it is Not Empty, then set newNode →
next = top.
 Step 5 - Finally, set top = newNode.
POP
 Step 1 - Check whether stack is Empty (top == NULL).
 Step 2 - If it is Empty, then display "Stack is Empty!!!
Deletion is not possible!!!" and terminate the function
 Step 3 - If it is Not Empty, then define a Node pointer
'temp' and set it to 'top'.
 Step 4 - Then set 'top = top → next'.
 Step 5 - Finally, delete 'temp'. (free(temp)).
Display
 Step 1 - Check whether stack is Empty (top == NULL).
 Step 2 - If it is Empty, then display 'Stack is
Empty!!!' and terminate the function.
 Step 3 - If it is Not Empty, then define a Node
pointer 'temp' and initialize with top.
 Step 4 - Display 'temp → data --->' and move it to the
next node. Repeat the same until temp reaches to the first
node in the stack. (temp → next != NULL).
 Step 5 - Finally! Display 'temp → data ---> NULL'.
Applications of Stack
 Stacks can be used for expression evaluation.
 Stacks can be used to check parenthesis matching in an
expression.
 Stacks can be used for Conversion from one form of
expression to another.
 Stacks can be used for Memory Management.
 Stack data structures are used in backtracking problems.
Representation of an expression
 An expression can be represented in three ways

 Infix expression

 Prefix expression

 Postfix expression
 Infix Notation
 Operators are written in-between their operands
 This is the usual way we write expressions
 Eg: A * ( B + C ) / D

 Post fixNotation
 Operators are written after their operands
 The postfix notation is called as suffix notation and is also referred to
reverse polish notation.
 Eg: A B C + * D /

 Prefix Notation
 Operators are written before their operands
 The prefix notation is called as polish notation
 Eg: / * A + B C D
 Algorithm to convert Infix to Postfix
1. Read all the symbols one by one from left to right in the given
Infix Expression.
2. If the reading symbol is operand, then directly print it to the
result (Output).
3. If the reading symbol is left parenthesis '(', then Push it on to the
Stack.
4. If the reading symbol is right parenthesis ')', then Pop all the
contents of stack until respective left parenthesis is poped and
print each poped symbol to the result.
5. If the reading symbol is operator (+ , - , * , / etc.,), then Push it
on to the Stack. However, first pop the operators which are
already on the stack that have higher or equal precedence than
current operator and print them to the result.
6. Repeat the process until the last symbol
Infix Exp: (A+(B*C-(D/E^F)*G)*H)
Infix to Prefix
 More Problems
 The following infix expressions convert to Postfix and Prefix
expressions
 1. (A + B) * (C + D)
 2. (A - B/C) * (A/K-L)
 3.(1+4/2*1+2)*3/2
 4.9*(12+4)/5*6
 5.(a*b/c)-(d^e+f)
Postfix Evaluation
 A postfix expression can be evaluated using the Stack data
structure. Follow the below steps
1. Read all the symbols one by one from left to right in the given
Postfix Expression
2. If the reading symbol is operand, then push it on to the Stack.
3. If the reading symbol is operator (+ , - , * , / etc.,), then
perform TWO pop operations and store the two popped
oparands in two different variables (operand1 and operand2).
Then perform reading symbol operation using operand1 and
operand2 and push result back on to the Stack.
4. Finally! perform a pop operation and display the popped value
as final result.
Postfix Evaluation
 456*+
Prefix Evaluation
 Step 1: Put a pointer P at the end of the end
 Step 2: If character at P is an operand push it to Stack
 Step 3: If the character at P is an operator pop two elements
from the Stack. Operate on these elements according to the
operator, and push the result back to the Stack
 Step 4: Decrement P by 1 and go to Step 2 as long as there
are characters left to be scanned in the expression.
 Step 5: The Result is stored at the top of the Stack, return it
Step 6: End
Prefix Evaluation
 Queue
 Queue is a linear data structure in which the insertion and
deletion operations are performed at two different ends.
 In a queue data structure, adding and removing elements are
performed at two different positions.
 The insertion is performed at one end and deletion is
performed at another end.
 In a queue data structure, the insertion operation is performed
at a position which is known as 'rear' and the deletion
operation is performed at a position which is known as 'front'.
 In queue data structure, the insertion and deletion operations
are performed based on FIFO (First In First Out) principle.
Operations on a Queue
 The following operations are performed on a queue data
structure...
 enQueue(value) - To insert an element into the
queue
 deQueue() - To delete an element from the queue
 display() - (To display the elements of the queue)
 Implementation of Queue
 Queue data structure can be implemented in two ways. They
are as follows...
 1.Using Array
 2.Using Linked List

 When a queue is implemented using an array, that queue can

organize an only limited number of elements.

 When a queue is implemented using a linked list, that queue

can organize an unlimited number of elements.
Queue Operations using Array
 Queue data structure using array can be implemented as follows...
Step 1 - Include all the header files which are used in the
program and define a constant 'SIZE' with specific value.
 Step 2 - Declare all the user defined functions which are used
in queue implementation.
 Step 3 - Create a one dimensional array with above defined SIZE
(int queue[SIZE])
 Step 4 - Define two integer variables 'front' and 'rear' and
initialize both with '-1'. (int front = -1, rear = -1)
 Step 5 - Then implement main method by displaying menu of
operations list and make suitable function calls to perform
operation selected by the user on queue.
 Insertion
 In a queue data structure, enQueue() is a function used to
insert a new element into the queue.
 In a queue, the new element is always inserted
at rear position.
 Step 1 - Check whether queue is FULL. (rear == SIZE-1)
 Step 2 - If it is FULL, then display "Queue is FULL!!!
Insertion is not possible!!!" and terminate the function.
 Step 3 - If it is NOT FULL, then increment rear value by one
(rear++) and set queue[rear] = value.
Deletion
 In a queue data structure, deQueue() is a function used to delete an
element from the queue.
 In a queue, the element is always deleted from front position
 Step 1 - Check whether queue is EMPTY. (front == rear)
 Step 2 - If it is EMPTY, then display "Queue is EMPTY!!!
Deletion is not possible!!!" and terminate the function.
 Step 3 - If it is NOT EMPTY, then increment the front value by
one (front ++). Then display queue[front] as deleted element.
Then check whether both front and rear are equal
(front == rear), if it TRUE, then set both front and rear to '-1'
(front = rear = -1).
Display
 Use the following steps to display the elements of a queue...
 Step 1 - Check whether queue is EMPTY. (front ==
rear)
 Step 2 - If it is EMPTY, then display "Queue is
EMPTY!!!" and terminate the function.
 Step 3 - If it is NOT EMPTY, then define an integer
variable 'i' and set 'i = front+1'.
 Step 4 - Display 'queue[i]' value and increment 'i' value by
one (i++). Repeat the same until 'i' value reaches
to rear (i <= rear)
Queue using Linked list
 The major problem with the queue implemented using an
array is, It will work for an only fixed number of data values.
 That means, the amount of data must be specified at the
beginning itself.
 Queue using an array is not suitable when we don't know the
size of data which we are going to use.
 A queue data structure can be implemented using a linked
list data structure.
 The queue which is implemented using a linked list can work
for an unlimited number of values.
Queue Operations using Linked list
 In linked list implementation of a queue, the last inserted
node is always pointed by 'rear' and the first node is always
pointed by 'front’
Operations
 To implement queue using linked list, we need to set the
following things before implementing actual operations.
 Step 1 - Include all the header files which are used in the
program. And declare all the user defined functions.
 Step 2 - Define a 'Node' structure with two
members data and next.
 Step 3 - Define two Node pointers 'front' and 'rear' and
set both to NULL.
 Step 4 - Implement the main method by displaying Menu of
list of operations and make suitable function calls in
the main method to perform user selected operation.
enQueue(value) - Inserting an element
into the Queue
 use the following steps to insert a new node into the queue...
 Step 1 - Create a newNode with given value and set
'newNode → next' to NULL.
 Step 2 - Check whether queue is Empty (rear == NULL)
 Step 3 - If it is Empty then,
set front = newNode and rear = newNode.
 Step 4 - If it is Not Empty then, set rear →
next = newNode and rear = newNode.
deQueue() - Deleting an Element from
Queue
 use the following steps to delete a node from the queue...
 Step 1 - Check whether queue is Empty (front ==
NULL).
 Step 2 - If it is Empty, then display "Queue is Empty!!!
Deletion is not possible!!!" and terminate from the
function
 Step 3 - If it is Not Empty then, define a Node pointer
'temp' and set it to 'front'.
 Step 4 - Then set 'front = front → next' and delete
'temp' (free(temp)).
display() - Displaying the elements of
Queue
 Use the following steps to display the elements (nodes) of a
queue...
 Step 1 - Check whether queue is Empty (front == NULL).
 Step 2 - If it is Empty then, display 'Queue is Empty!!!' and
terminate the function.
 Step 3 - If it is Not Empty then, define a Node
pointer 'temp' and initialize with front.
 Step 4 - Display 'temp → data --->' and move it to the next
node. Repeat the same until 'temp' reaches to 'rear' (temp →
next != NULL).
 Step 5 - Finally! Display 'temp → data ---> NULL'.
Applications of Queue
 1. It is used to schedule the jobs to be processed by the
CPU.

 2. When multiple users send print jobs to a printer, each

printing job is kept in the printing queue. Then the printer
prints those jobs according to first in first out (FIFO) basis.

 3. Breadth first search uses a queue data structure to find an

element from a graph.
Types of Queue
 There are four types of Queue:
 Simple Queue
 Circular Queue
 Priority Queue
 Dequeue (Double Ended Queue)
Circular Queue
 In a normal Queue Data Structure, we can insert elements
until queue becomes full.
 But once the queue becomes full, we can not insert the next
element until all the elements are deleted from the queue.
 The queue after inserting all the elements into it is as follows
Circular Queue
 After deleting three elements from the queue...

•In the above situation, even though we have empty positions in the
queue we can not make use of them to insert the new element.
• This is the major problem in a normal queue data structure.
•To overcome this problem we use a circular queue data structure.
Circular Queue
 A circular queue is a linear data structure in which the
operations are performed based on FIFO (First In First Out)
principle and the last position is connected back to the first
position to make a circle.
 Graphical representation of a circular queue is as follows..
 Implementation of Circular Queue
 To implement a circular queue data structure using an array
 Step 1 - Include all the header files which are used in the
program and define a constant 'SIZE' with specific value.
 Step 2 - Declare all user defined functions used in
circular queue implementation.
 Step 3 - Create a one dimensional array with above defined
SIZE (int cQueue[SIZE])
 Step 4 - Define two integer variables 'front' and 'rear' and
initialize both with '-1'. (int front = -1, rear = -1)
 Step 5 - Implement main method by displaying menu of
operations list and make suitable function calls to perform
operation selected by the user on circular queue.
 enQueue(value) - Inserting value into
the Circular Queue
 In a circular queue, enQueue() is a function which is used to insert
an element into the circular queue.
 In a circular queue, the new element is always inserted
at rear position.
 Step 1 - Check whether queue is FULL. ((rear == SIZE-1 &&
front == 0) || (front == rear+1))
 Step 2 - If it is FULL, then display "Queue is FULL!!!
Insertion is not possible!!!" and terminate the function.
 Step 3 - If it is NOT FULL, then check rear == SIZE - 1 &&
front != 0 if it is TRUE, then set rear = -1.
 Step 4 - Increment rear value by one (rear++),
set queue[rear] = value and check 'front == -1' if it is TRUE,
then set front = 0.
deQueue() - Deleting a value from the
Circular Queue
 In a circular queue, deQueue() is a function used to delete an
element from the circular queue.
 In a circular queue, the element is always deleted
from front position.
 Step 1 - Check whether queue is EMPTY. (front == -1 &&
rear == -1)
 Step 2 - If it is EMPTY, then display "Queue is EMPTY!!!
Deletion is not possible!!!" and terminate the function.
 Step 3 - If it is NOT EMPTY, then display queue[front] as
deleted element and increment the front value by one (front
++). Then check whether front == SIZE, if it is TRUE, then
set front = 0. Then check whether both front - 1 and rear are
equal (front -1 == rear), if it TRUE, then set
both front and rear to '-1' (front = rear = -1).
display() - Displays the elements of a
Circular Queue
 Step 1 - Check whether queue is EMPTY. (front == -1)
 Step 2 - If it is EMPTY, then display "Queue is EMPTY!!!" and
terminate the function.
 Step 3 - If it is NOT EMPTY, then define an integer variable 'i' and set
'i = front'.
 Step 4 - Check whether 'front <= rear', if it is TRUE, then display
'queue[i]' value and increment 'i' value by one (i++). Repeat the same
until 'i <= rear' becomes FALSE.
 Step 5 - If 'front <= rear' is FALSE, then display 'queue[i]' value
and increment 'i' value by one (i++). Repeat the same until'i <= SIZE
- 1' becomes FALSE.
 Step 6 - Set i to 0.
 Step 7 - Again display 'cQueue[i]' value and increment i value by one
(i++). Repeat the same until 'i <= rear' becomes FALSE.
Double Ended Queue-Deque
 Double Ended Queue is also a Queue data structure in which
the insertion and deletion operations are performed at both
the ends (front and rear).
 That means, we can insert at both front and rear positions
and can delete from both front and rear positions.
Operations on Deque
Mainly the following four basic operations are performed on
queue:
 insertFront(): Adds an item at the front of Deque.
 insertLast(): Adds an item at the rear of Deque.
 deleteFront(): Deletes an item from front of Deque.
 deleteLast(): Deletes an item from rear of Deque.
Deque
 Double Ended Queue can be represented in TWO ways,
those are as follows...

 Input Restricted Double Ended Queue

 Output Restricted Double Ended Queue
 Input Restricted Double Ended Queue
 In input restricted double-ended queue, the insertion operation
is performed at only one end and deletion operation is
performed at both the ends.
Output Restricted Double Ended Queue
 In output restricted double ended queue, the deletion
operation is performed at only one end and insertion
operation is performed at both the ends.