DATA STRUCTURE

• What is data structure?

It is a branch of computer science or computer application, in which we
study about “ how to organise data in computer memory and how to use
it efficiently”.
• Need/ Characteristics/Features:
1. Correctness
2. Time complexity
3. Space complexity
• Complexity is the way of calculating “ how much time and space has
taken by a program for its execution.”
• Complexity is of three types:-
I. Worst case ( 10sec. 1 KB ) ( 15sec. 1528B)
II. Average case (10sec. 1KB) ( 9sec. 1KB)
III. Best case (10sec. 1KB). (5sec. 100B)
NOTE:- Time has the first preference.

ALGORITHM
Algorithm in data structure is defined as “Set of predefined steps” to
complete a particular task or program.
It is written in two ways :
I. Pseudocode
II. General english language
PSEUDOCODE
It is not a programming method or not follow the complete programming.
It just uses some Keywords of programming and write down the
necessary steps related to a programming.
Eg:-
1. Initialise I=1,sum,n
2. For I=1 to n
sum= sum + I
3. Print sum.
TYPES OF DATA STRUCTURE:
1. Linear:
I. Array
II. Stack
III. Queue
IV. Linked list
2. Non Linear:
I. Tree
II. Graph
LINEAR DATA STRUCTURE:
Linear data structure are those in which data is stored sequentially i.e.
follow a specific order .
ARRAY:
It is a data structure which stores multiple variable of same type.
It stores variables of same type.
• Advantages:-
I. It reduces memory space consumption.
II. It reduces reading complexity.
• Disadvantages:-
 I. It stores data of same type.
• According to declaration TYPES OF ARRAY:
1. Static
2. Dynamic
STATIC ARRAY:
The array which do not take runtime input or which can not be
modified is called static array.
Eg:-. Int A[5] = {20,34,25,67,8};
DYNAMIC ARRAY:
The array which can be modified or which takes runtime input is
called dynamic array.
Eg :- int A[5];
• According to dimensions TYPES OF ARRAY:
1. One dimensional
2. Two or multi dimensional
ONE DIMENSIONAL:
The array which have one row and multiple columns are called one
dimensional array.
Eg :- int A[5];
MULTI DIMENSIONAL:
The array which have multiple row and multiple columns are called
multi dimensional array.
Eg :- int A[3][4];
STACK:
It is a linear data structure.
 Stack follows LIFO or FILO pattern.
LIFO – Last In First Out
FILO – First In Last Out
Eg :- Washing cloths in a tub.
Arrangements of plates in a party.
Diagram:
Push (value). Pop(0)
Top

STACK
• Operations:-
I. Push() – To insert data on top of stack.
II. Pop() – To delete from top of stack.
• Perform postfix operation on following
10,20,+,20,40,*,89,-
Push(10)

10

Push(20)

20
 10
Push(+)

+
20
10
Pop(0)

30
Push(20)

20
30
Push(40)

40
20
30
Push(*)
*
40
20
30
Pop(0)
 800
30
Push(80)

80
800
30
Push(-)
-
80
800
30
Pop(0)

720
30

• Algorithm:-
• Push
1. Take an array called stack.
2. Check if stack is empty or not

If not empty
“stack is full”
Exit.

If empty
Push data from top.
 Top is increased by 1 step.
3. Repeat step 2.
• Pop
1. Take an array called stack.
2. Check if stack is empty or not
If empty
“stack is empty”
Exit.
If not empty
Pop data from top.
Top is decreased by 1 step.
3. Repeat step 2.
QUEUE:
• It is a linear data structure.
• It follows FIFO or LILO pattern.
FIFO – First In First Out
LILO – Last In First Out
• Data is inserted through rear end and deleted through front .
Eg :-. Ticket counter.

• Operations:-
I. Enqueue – Insert data in queue from rear end.
II. Dequeue – To delete data from queue from front end.
• Diagram:-
Front Rear

Queue is a horizontal data structure.

• TYPES OF QUEUE:

1. Simple queue

The queue which have only one front and one rear is called simple
queue .
Front. Rear

Algorithm for enqueue:

I. Take an array , called queue.
II. Check queue is empty or not.
If not empty
Queue is full.
Exit.
If empty
Insert from rear end
Rear is increased by 1 place.
III. Repeat step II.
Algorithm for dequeue:
I. Take an array called queue.
II. Check queue is empty or not .
If empty
Queue is empty.
 Exit
If not empty
Delete from front end.
Front is decreased by 1 place.

2. Priority queue

The queue in which rear and front is taken on same place is called as
priority queue.

In this enqueue and dequeue is associated with the arrival of data.

Algorithm:
I. Take an array called queue .
II. Check queue is empty or not.
If not empty
Perform dequeue operation on less value data.
Choose your data on priority base and insert it in the
Place of less value data.

3. Circular queue

The queue in which the last element or front is associated with the
first element or rear through a link .
Or It is defined as rear and front is taken on both side of queue.

Enqueue Algorithm:
I. Check if queue is full .
II. For the first element set value of front as 0.
 III. Circularly increase the rear index by 1.(it means if rear index
reaches the end, next it would be the start of the queue.)
IV. Add the new element in the position pointed by rear.
Dequeue Algorithm:
I. Check if queue is empty.
II. Return the value pointed by front.
III. Circularly increase the front index by 1.
IV. For the last element reset the value of front.

4. Deque

It stands for double ended queue.

It is a special type of queue in which enqueue and dequeue
performed from both end.

There are two types of deque:-

I. Input restricted deque – It allow insertion from only one end
and deletion from both side.
II. Output restricted deque – It allow deletion from only one end
and insertion from both end.
Algorithm for insert from front:
1. Check the position of front.
2. If front < 1
Initialise at the first index .
3. Add the new value in front index.
4. If front >= 1
Add the element in position of front.
Algorithm for insert at rear:
 1. Check the array is full or not.
2. If queue is full
Initialise rear =0
3. Add the element at the position of rear.
4. If queue is not full
Find position of rear.
5. Add the element at rear index.
Algorithm for delete from front:
1. Check queue is empty or not
2. If empty
Queue is empty.
Exit.
3. If not empty
Find position of front index.
Delete the data of front index.
Front is decreased by 1.
Algorithm for delete from rear:
1. Check queue is empty or not.
2. If empty
Queue is empty.
Exit.
3. If not empty
Delete from rear end.
Rear is decreased by 1.

Prefix Infix Postfix

+AB A+B AB+
-+ABC A+B-C AB+C-
+A-BC. Or +AC-B or. A-B+C AC+-B. Or A-BC+ or
-+ABC. Or. -+ACB AC+B-. Or ABC+-
-+A*BCD or A-B*C+D ABC*D+- or
-+AD*BC AD+BC*-

SORTING:
Sorting in data structure is a concept by which we are able to arrange data
in a particular order i.e. ascending or descending.
Eg:- 14,27,35,28,10
Ascending – 10,14,27,28,35
Descending – 35,28,27,14,10
In other words sorting is a process by which rearrangement of a given
array or list of elements according to a comparison operator on the
elements is done. The comparison operator is used to decide new order
of the elements.
Sorting Algorithm Are Divided Into 6 Categories:-
I. Bubble sort
II. Quick sort
III. Merge sort
IV. Insertion sort
V. Selection sort
VI. Heap sort
Others are :-
I. Counting sort
II. Radix sort
III. Bucket sort
IV. Bingo sort
 V. Shell sort
VI. Tim sort
VII. Combo sort
VIII. Pigeonhole sort
IX. Cycle sort
X. Cocktail sort
XI. Strand sort
XII. Bitonic sort
XIII. Pancake sort
XIV. Bogo/Permutation sort
XV. Sleep sort
XVI. Tag sort
XVII. Tree sort
XVIII. Odd even sort
XIX. 3-way merge sort
BUBBLE SORT:
It is a simplest sorting algorithm that works by repeatedly swapping the
adjacent elements of they are not in particular order.
This is suitable for less no. Of elements not more than 50 because the
complexity of bubble sort is quite high for large data set.
Eg :- 14,28,27,35,10
Step 1. 14,28,27,35,10
Step 2. 14,27,28,35,10
Step 3. 14,27,28,35,10
Step 4. 14,27,28,10,35
Step 5. 14,27,28,10,35
Step 6. 14,27,28,10,35
Step 7. 14,27,10,28,35
Step 8. 14,27,10,28,35
Step 9. 14,27,10,28,35
Step 10. 14,10,27,28,35
Step 11. 14,10,27,28,35
Step 12. 14,10,27,28,35
Step 13. 10,14,27,28,35
Complexities of bubble sort:-
I. Worst. - O(n2)
II. Best - Omega (n)
III. Average - Theta(n+1)
Algorithm:-
1. Take an unsorted array.
2. Move from left to right and compare adjacent elements , place
the higher value element in right side between both elements.

In this way the largest element move to the rightmost end at

the end of 1st cycle.
3. Repeat step 2 until the array is sorted.
QUICK SORT:
It is a sorting algorithm based on divide and conquer algorithm.
From the unsorted array it picks an element as pivot (random elements)
and partition the given array around the picked pivot by placing in the
correct position of sorted array.
Eg :- 10,80,30,90,40. Pivot -40.
 10,40,80,30,90. Pivot -. 30.
10,30,40,80,90
Algorithm:-
1. Take an unsorted array.
2. Choose an element called pivot
3. Compare the pivot element from each and every element of the
unsorted array
If pivot > element
Pivot is placed in right side of given element
Repeat step 3
If pivot < element
Place the pivot in left side
Break
Repeat step 2 till sorted.
Complexities of quick sort :-
I. Worst - O(n^2)
II. Best - Theta (n log n)
III. Average - Omega (n log n)
Advantages:-
I. Due to divide and conquer algorithm it is easy to solve .
II. It is efficient on large data set.
III. It require small amount of memory.
Disadvantages:-
I. If pivot is chosen poorly , then wort case time complexity of O
(n^2).
II. It is not useful for small data set.
III. It is taken as wrong when two elements have same data value.
MERGE SORT:
It is a sorting algorithm based on divide and conquer algorithm.
It divides an unsorted array in small parts (every part has got max. Two
elements).
Sorting each subarray ( each part) and then merge it from where it is
break till sorted.
Eg :-. 38,27,43,10
38, 27. 43, 10
27,38. 10,43
10,27,38,43

Algorithm:-
1. Take an unsorted array.
2. By following recursive algorithm that continuously split the
array in half until it cannot be further divided ( each part having
max 2 elements).
3. Compare each and every part and sort it between the parts.
4. Merge the sorted part from where it is divided.
5. Again sort it recursively till the array is sorted.
Complexities in merge sort:-
I. Worst - O (n log n )
II. Best - Omega(n log n )
III. Average - Theta(n log n)
INSERTION SORT
It is a simple sorting algorithm that work similar to the way you are
playing cards.
In this sorting algorithm the given array is virtually split in two parts i.e.
sorted and unsorted.
Values from the unsorted part are picked and placed in the sorted part.
Eg :- 12,11,13,5,6
11,12,13,5,6
11,12,5,13,6
11,5,12,13,6
5,11,12,13,6
5,11,12,6,13
5,11,6,12,13
5,6,11,12,13

Algorithm :-
1. Take an unsorted array.
2. Take the first element and compare it to the adjacent element
I. If first element > adjacent element
Swap first element with adjacent element.
Compare adjacent element with previous if exist.
Repeat step 2.
II. If first element < adjacent element
No swapping required.
First position increased by 1.
Exit.
Complexities of insertion sort:-
I. Worst - O ( n^2)
II. Best - Omega ( n log n)
III. Average - Theta (n)
SELECTION SORT
It is a simple and efficient sorting algorithm that work by repeatedly
selecting the smallest element from the unsorted array and move it to the
sorted position of array.
Eg. :- 11 , 12,13,5,6
5,11,12,13,6
5,6, 11, 12, 13
Algorithm:-
3. Take an unsorted array.
4. Choose 1st element and compare it with all the other elements
existing in array.
5. It picks the lowest valued element and place in the first place.
6. First position is increased by 1 and repeat step 2.
Complexities of selection sort:-
I. Worst - O ( n^2)
II. Best - Omega ( n log n)
III. Average - Theta (n)

LINKED LIST:
Linked list in data structure consist of elements with different datatype
that are arranged sequentially.
In other words,
Linked list is a collection of nodes connected together via links. These
nodes are consist of data to be sorted and the pointer which contain the
address of another nodes.
In array , we know that the size of array is fixed which is defined by user
but in linked list there is no defined size.
There are three types of linked list :-
1. Singly Linked List – The node only point the address of next node is
called singly .
2. Doubly Linked List – The node of a linked list which point to the
address of both previous and next node.
3. Circular Linked List – The last node of a linked list contains the point
of address to connect the first node of the linked list.
Diagram Representation:-

Note :-
A singly linked list contain only two bucket in the node , one hold the data
and other hold the address of next node.
Singly linked list only move in forward direction.

Note :-
Doubly linked list contain three bucket , one bucket hold the data and
the other buckets hold the address of previous and next node.
Doubly linked list move in both forward and backward direction.

Note:-
Circular linked list contains both singly and doubly linked list. It also
contain three buckets as in doubly linked list.
It move in both forward and backward direction.

BASIC OPERATIONS ON LINKED LIST:

1. Insertion – To insert data in the list.
2. Deletion – To delete node from the list.
3. Traversing – Display the complete list.
 4. Searching – Find an element in list.
5. Delete – To delete an element using the given key.(It include search
operation)
Algorithm to insert at beginning :
1. Take an array called linked list.
2. Create a node to store data.
3. If empty
Assign the data on node and connect it to the head.
4. If not empty
List is full.
Insert at new node created by user and connect it to the head.
Algorithm to insert at any position:
1. Take an array called linked list.
2. Create a node to store data.
3. Check if list is empty or not.
4. If empty
Assign the data on the node.
5. If not empty
List is full.
Insert at the new node created by user.
Algorithm for creating node at the beginning:
1. Make the first node of the linked list to the new node.
2. Remove the head connected to the original 1st node of the existing
linked list.
3. Connect the new node to the head.
Algorithm to create node at middle:
1. Find the position you want to create the node.
 2. Create a node with data and next.
3. Remove the previous connectivity between previous node and next
node.
4. Connect the new node ( data with pointer of previous node and New
pointer with the data of next node.)
Algorithm to create node at end :
1. Go to the last node of the linked list.
2. Change the next pointer of last node from null to data of new node.
3. Connect the pointer of new node with null.
Algorithm to delete a node at beginning:
1. From an existing linked list remove the connectivity of first node with
next node and head with first node.
2. Connect the head with the data of next node.
Algorithm to delete node at middle :
1. From an existing linked list choose the node you want to delete.
2. Remove the connectivity of the given node with previous and next
node.
3. Connect the pointer of previous node with the next node.
Algorithm to delete node at last :
1. Go to the last node of an existing linked list.
2. Remove the connectivity of last node with previous node and null.
3. Connect the pointer of previous node with null.
Algorithm for searching in linked list :
1. From an existing list , choose the element you want to search,place it
in the head.
2. If the current value equal the given element , then return it as search
value.
 3. Otherwise, move to the next node and repeat step 2.
4. If the pointer shows null then it return as “search element not
found.”
TREE:
A tree is a non linear hierarchical data structure that consists of node
connected by edges.

Node :
- A node is an entity represented in circular, rectangular or square
which contains key value and the pointer .
- The last node or the bottom node is called as leaf node or child
node.
- Leaf node are those nodes which contains only key value and
not the pointer.
Edge :
It is a link between two nodes .
Root :
The topmost part is called root.
Or,
The node which contain both data and pointer.
Height Of a Node :
Height of a Node is the no. Of edges from the node to the deepest leaf
node.
In other words, longest path from the given node to leaf node is called
height of a Node.
Height Of A Tree:
The distance from topmost root to the deepest leaf node is called as
height of a tree.
Degree of a Node:
Degree of node is the total number of branches of the given node.
FOREST:
A collection of disjoint tree is called a forest.

Tree is divided into 4 categories:-

1. Binary tree
2. Binary search tree
3. AVL tree
4. B-Tree
Uses of tree :-
- B-tree is use to store collection of multiple non- sequential data.
- If you want to design a compiler then for validation AVL tree are
used.
- BST is used for quick searching.
- Binary tree are used for heap sort.
Tree Traversal :
In order to perform any Operation on a tree you need to move to the
specific node is called tree Traversal.
A tree data structure can be traversed in following ways :
1. Depth First Search or DFS
I. Inorder traversal
II. Preorder traversal
III. Postorder traversal
2. Level Order Traversal or Breadth First Search or BFS.
3. Boundary Traversal
4. Diagonal Traversal

Algorithm for Inorder Traversal:

1. Traverse the left subtree , i.e. , call Inorder(left-> subtree)
2. Visit the root.
3. Traverse the right subtree,i.e. , call Inorder (right-> subtree)
Algorithm for Preorder Traversal :
1. Visit the root .
2. Traverse the left subtree , i.e. , call Preorder (left-> subtree).
3. Traverse the right subtree,i.e. , call Preorder (right-> subtree).
Algorithm for postorder Traversal :
1. Traverse the left subtree , i.e. , call Preorder (left-> subtree).
2. Traverse the right subtree,i.e. , call Preorder (right-> subtree).
3. Visit the root.
Level Order Traversal :
For each node , first , the node is visited and then it's child nodes are out
in a FIFO queue, Then again the first node is popped out and then it's
child node are put in a FIFO queue and repeat until queue becomes
empty.
Example:

Boundary Traversal :
The boundary Traversal of a Tree includes:
1. Left Boundary ( nodes on left excluding leaf nodes)
2. Leaves ( consists of only the leaf nodes.)
3. Right boundary ( nodes on right excluding leaf nodes.)
Diagonal Traversal :
In the Diagonal Traversal of a Tree , all the nodes in a single diagonal will
be printed one by one.

Binary Trees:
The tree in which each parent node has at most two child node.
In other words, a binary tree in tree data structure is defined as each root
node has maximum two leaf node i.e. existing 0,1,or 2 node.
Each node of a binary tree contains data , pointer of left node address and
right node address .
There are 6 types of binary tree :-
I. Full Binary Tree :
A full Binary tree is a special type of tree in which each parent
node has 2 – leaf node or no leaf node.

II. Perfect Binary Tree :

 A perfect Binary tree is a type of binary tree in which every
parent node have 2- children or no children but every level
should have 2- children or no children.
III. Complete Binary Tree :
A complete binary tree is just like full Binary tree but with
three differences.
a. All the leaf must lean towards left.
b. Every level must be completely filled.
c. The last leaf element might not have a right sibling.
IV. Degenerate or Pathological Tree :
A degenerate or Pathological tree having single child either in
left or right.

V. Skewed Binary Tree :

A skewed Binary tree is a pathological / degenerate tree in
which the tree is either dominated by the left node or the
right node. Thus it is categorised in two categories:-
a. Left skewed tree
b. Right skewed tree
 VI. Balanced tree :
Balanced tree is those tree in which the difference of right
node from left node is -1,0 or 1 in each node of the given
tree.
Binary Search Tree (BST) :
- Binary search tree in data structure quickly allow us to maintain
a sorted list of numbers.
- It is called a binary tree because each tree has maximum two
children.
- It is called a search tree because it can be used to search a key
value in less amount of time .
- Time complexity of binary search tree is O(n log n).
Properties :-
1. All nodes data of left subtree are less than the root node .
2. All nodes data of right subtree is more than the root node.
3. Each and every leaf node of each subtree follow the step 1 & 2.
Operation on BST :-
1. Searching – To find a key value.
Algorithm:-
I. If root == NULL
Return “ Tree not found.”
II. Elseif root == data
Return root -> data.
III. Elseif root > data
Return search(root->left).
IV. Elseif root < data
Return search(root->right).
2. Inserting – To insert data in tree.
 Algorithm :-
I. If root == NULL
Return create node(data)
II. Elseif data<( node-> data)
Return node-> left = insert(create node(data)).
III. Elseif data > (node-> data)
Return node -> right = insert(create node( data)).
3. Deletion –
CASE I
In first case of deletion operation,if the node to be deleted
existed in the leaf node simply delete that node (by following
the search operation).
CASE II
In second case the node to be deleted has single child node
follow:-
a. Replace that node with child node.
b. Remove the child node by following case I.
CASE III
In third case the node to be deleted has two children follow:-
a. Get the inorder successor of that node.
b. Replace the node with inorder successor .
c. Remove the inorder successor from original position.
Application :-
1. In a multi-level indexing of the database BST is used.
2. Dynamic/ heap sorting.
3. In Linux, for managing virtual memory location , BST is used.
AVL Tree :-
- AVL tree is a self balance tree in which each node maintain the
balance factor of -1,0,1.
 - It follows the concept of binary search tree ( the right node
value > root node and the left node has less value than root
node).
- BALANCE FACTOR – Balance factor in AVL tree is defined as the
difference of the height of right subtree to the height of left
subtree.
Balance Factor = height of right subtree – height of left subtree.
- AVL tree got its name after its inventer “ George Adelson-
Velsky” and “Landis”.

Operation on AVL tree:-

1. Insertion
2. Searching
3. Deletion
4. Rotation
Rotation in AVL tree means the position of the node of a
subtree , root node are interchanged.
Types:-
I. LL ( Left Left)
II. LR ( Left Right)
III. RL ( Right Left)
IV. RR ( Right Right)
B- Tree :
- B-Tree in data structure is defined as special type of self
balancing search tree in which each node contain more than
one key and can have more than two children.
- It is a generalised form of binary search tree.
- It is also known as a height balanced M- way tree.

Need of B-Tree :
I.) Other tree data structures such as Binary
Search Tree, AVL Tree , etc can store only
one key in one node. If you have to store a
large no. Of keys than , the height of such
type of tree become very large and the
access time to access such type of data also
increases.
However, B-Tree can store many keys in
single node and can also have multiple child
node. This decrease the height significantly
allowing faster data access time.
II.) It minimise the complexity of arrangement
of data in memory.
III.) It is easily usable in HD, SDD, and other type
of secondary storage.
IV.) It increases the capacity, reliability,
performance, disk access time.
Properties of B-Tree :
- For each node the keys are stored in increasing order.
- In each node there is a Boolean value acceptable.
- If a B-Tree has order of “m” let (m=4)
 Then, maximum keys. = m-1. (4-1=3)
Then, minimum keys. = (m/2)-1. (4/2-1 = 2-1 =1)
Then, maximum children = m. (4)
Then, minimum children. = m/2. (4/2=2)
Operation on B-Tree :
1. Searching – Searching for an element in a B-Tree is the
generalised form of searching an element in search
tree.
Following steps are followed :
a. Starting from the root node , compare 'k' with the
first key node :

If k= the 1st key of the node return the node and the
index.

If k.leaf = true , return NULL (element not found in

given tree).

If k < the 1st key of root node, search the leaf child
of this node and the key recursively by following
step 1.

If k > the 1st key of root node , search the right side
of this node and the key recursively by following
step 1.

Repeat step 1 to 4 until the process reach the goal.

 2. Insertion – Inserting an element in B-Tree consist of
two events.
a. ) Searching the appropriate node.
b. ) Splitting the node if required.
Insertion always follows bottom-up approach.
Algorithm for insertion :
1. If tree is empty , allocate a root node and insert the key.
2. Update the allowed no. Of keys in the node.
3. Search the appropriate node for insertion .
4. If the node is full follow the steps below :
a. Insert the element in increasing order .
b. Now, there are elements greater than split at the median.
c. Put the median key upward and the left child and the right key
as right child.
d. If node is not full follow the step 4.
Q. 1. Design a B-Tree with following data 8,9,10,11,15,20,17.
Q.2. Design B-Tree of order 4 with 5,3,21,9,13,22,7,10,11,14,8,16.
Q 3. Design a B-Tree of order 3 with following data 4,2,20,10,1,14,7,11,3,8