Non-linear Data Structures

Data structures where data elements are not arranged sequentially or linearly are
called non-linear data structures. In a non-linear data structure, single level is not
involved. Therefore, we can’t traverse all the elements in single run only. Non-
linear data structures are not easy to implement in comparison to linear data
structure. It utilizes computer memory efficiently in comparison to a linear data
structure. Its examples are trees and graphs.

Linear Vs Non-linear Data Structures

Linear Data Structures Non Linear Data Structures

The data items are arranged in sequential The data items are arranged in non-
order, one after the other. sequential order (hierarchical manner).

The data items are present at different

All the items are present on the single layer.
layers.

It can be traversed on a single run. That is, if It requires multiple runs. That is, if we start
we start from the first element, we can from the first element it might not be
traverse all the elements sequentially in a possible to traverse all the elements in a
single pass. single pass.

Different structures utilize memory in

The memory utilization is not efficient. different efficient ways depending on the
need.

The time complexity increase with the data

Time complexity remains the same.
size.

Example: Arrays, Stack, Queue Example: Tree, Graph, Map

Tree
Tree Data Structure is a non-linear data structure in which a collection of
elements known as nodes are connected to each other via edges such that there
exists exactly one path between any two nodes.
Tree data structure is a hierarchical structure that is used to represent and organize
data in the form of parent child relationship. The following are some real world
situations which are naturally a tree.
The topmost node of the tree is called the root, and the nodes below it are called
the child nodes. Each node can have multiple child nodes, and these child nodes
can also have their own child nodes, forming a recursive structure.
Basic Terminologies In Tree Data Structure:
 Parent Node: The node which is an immediate predecessor of a node is
called the parent node of that node. {B} is the parent node of {D, E}.
 Child Node: The node which is the immediate successor of a node is called
the child node of that node. Examples: {D, E} are the child nodes of {B}.
 Root Node: The topmost node of a tree or the node which does not have any
parent node is called the root node. {A} is the root node of the tree. A non-
empty tree must contain exactly one root node and exactly one path from the
root to all other nodes of the tree.
 Leaf Node or External Node: The nodes which do not have any child
nodes are called leaf nodes. {I, J, K, F, G, H} are the leaf nodes of the tree.
 Ancestor of a Node: Any predecessor nodes on the path of the root to that
node are called Ancestors of that node. {A,B} are the ancestor nodes of the
node {E}
 Descendant: A node x is a descendant of another node y if and only if y is
an ancestor of x.
 Sibling: Children of the same parent node are called siblings. {D,E} are
called siblings.
 Level of a node: The count of edges on the path from the root node to that
node. The root node has level 0.
 Internal node: A node with at least one child is called Internal Node.
  Neighbour of a Node: Parent or child nodes of that node are called
neighbors of that node.
 Subtree: Any node of the tree along with its descendant.
Types of TREE
The following are the different types of tree data structures:
 Binary Tree.
 Binary Search Tree (BST)
 AVL Tree.
 B-Tree.

(A) Binary Tree

A binary Tree is defined as a Tree data structure with at most 2 children. Since
each element in a binary tree can have only 2 children, we typically name them the
left and right child.
Example:
Consider the tree below. Since each node of this tree has only 2 children, it can be
said that this tree is a Binary Tree

Binary Tree
Types of Binary Tree:
 Binary Tree consists of following types based on the number of children:
1. Full Binary Tree
A full binary tree is a binary tree with either zero or two child nodes for
each node.

2. Degenerate Binary Tree

 On the basis of completion of levels, the binary tree can be divided into
following types:
1.Complete Binary Tree
A complete binary tree is a special type of binary tree where
all the levels of the tree are filled completely except the
lowest level nodes which are filled from as left as possible.

Complete Binary Tree

Properties of Complete Binary Tree:

  A complete binary tree is said to be a proper binary tree where all leaves

have the same depth.

 In a complete binary tree number of nodes at depth d is 2d.

 In a complete binary tree with n nodes height of the tree is log(n+1).

 All the levels except the last level are completely full.

2. Perfect Binary Tree

 A perfect binary tree is a special type of binary tree in
which all the leaf nodes are at the same depth, and all non-
leaf nodes have two children. In simple terms, this means that
all leaf nodes are at the maximum depth of the tree, and the
tree is completely filled with no gaps.
 The maximum number of nodes in a perfect binary tree is
given by the formula 2^(d+1) – 1, where d is the depth of
the tree. This means that a perfect binary tree with a depth of
n has 2^n leaf nodes and a total of 2^(n+1) – 1 nodes.

3. Balanced Binary Tree

Given a binary tree, determine if it is height-balanced. A binary tree is
considered height-balanced if the absolute difference in heights of the left and right
subtrees is at most 1 for every node in the tree.

An AVL tree defined as a self-balancing Binary Search Tree (BST) where the
difference between heights of left and right subtrees for any node cannot be more
than one.
 (B) AVL Tree
An AVL tree defined as a self-balancing Binary Search Tree (BST) where the
difference between heights of left and right subtrees for any node cannot be more
than one.
The difference between the heights of the left subtree and the right subtree for any
node is known as the balance factor of the node.
(C) B-Tree
A B-tree is a self-balancing tree where all the leaf nodes are at the same level
which allows for efficient searching, insertion and deletion of records. Because of
all the leaf nodes being on the same level, the access time of data is fixed
regardless of the size of the data set.
(D) Binary Search Tree
A Binary Search Tree (or BST) is a data structure used in computer science for
organizing and storing data in a sorted manner. Each node in a Binary Search
Tree has at most two children, a left child and a right child, with the left child
containing values less than the parent node and the right child containing values
greater than the parent node.
This hierarchical structure allows for efficient searching, insertion,
and deletion operations on the data stored in the tree.
Advantages of Binary search tree
 o Searching an element in the Binary search tree is easy as we always have a
hint that which subtree has the desired element.
o As compared to array and linked lists, insertion and deletion operations are
faster in BST.
Creation of Binary Search Tree
Now, let's see the creation of binary search tree using an example.
Suppose the data elements are - 45, 15, 79, 90, 10, 55, 12, 20, 50
o First, we have to insert 45 into the tree as the root of the tree.
o Then, read the next element; if it is smaller than the root node, insert it as the
root of the left subtree, and move to the next element.
o Otherwise, if the element is larger than the root node, then insert it as the
root of the right subtree.
Now, let's see the process of creating the Binary search tree using the given data
element. The process of creating the BST is shown below -
Step 1 - Insert 45.

Step 2 - Insert 15.

As 15 is smaller than 45, so insert it as the root node of the left subtree.
Step 3 - Insert 79.
As 79 is greater than 45, so insert it as the root node of the right subtree.

Step 4 - Insert 90.

90 is greater than 45 and 79, so it will be inserted as the right subtree of 79.
Step 5 - Insert 10.
10 is smaller than 45 and 15, so it will be inserted as a left subtree of 15.

Step 6 - Insert 55.

55 is larger than 45 and smaller than 79, so it will be inserted as the left subtree of
79.
Step 7 - Insert 12.
12 is smaller than 45 and 15 but greater than 10, so it will be inserted as the right
subtree of 10.

Step 8 - Insert 20.

20 is smaller than 45 but greater than 15, so it will be inserted as the right subtree
of 15.
Step 9 - Insert 50.
50 is greater than 45 but smaller than 79 and 55. So, it will be inserted as a left
subtree of 55.
Now, the creation of binary search tree is completed.
Operations of Binary Search Tree
(i)Searching
(ii)Insertion
(iii)Deletion
(iv)Traversal
(i) Searching
Searching means to find or locate a specific element or node in a data structure. In
Binary search tree, searching a node is easy because elements in BST are stored in
a specific order. The steps of searching a node in Binary Search tree are listed as
follows -
1. First, compare the element to be searched with the root element of the tree.
2. If root is matched with the target element, then return the node's location.
3. If it is not matched, then check whether the item is less than the root
element, if it is smaller than the root element, then move to the left subtree.
 4. If it is larger than the root element, then move to the right subtree.
5. Repeat the above procedure recursively until the match is found.
6. If the element is not found or not present in the tree, then return NULL.
Now, let's understand the searching in binary tree using an example. We are taking
the binary search tree formed above. Suppose we have to find node 20 from the
below tree.
Step1:

Step2:

Step3:
Now, let's see the algorithm to search an element in the Binary search tree.
Algorithm to search an element in Binary search tree
1. Search (root, item)
2. Step 1 - if (item = root → data) or (root = NULL)
3. return root
4. else if (item < root → data)
5. return Search(root → left, item)
6. else
7. return Search(root → right, item)
8. END if
9. Step 2 - END

(ii) Insertion
A new key in BST is always inserted at the leaf. To insert an element in BST, we
have to start searching from the root node; if the node to be inserted is less than the
root node, then search for an empty location in the left subtree. Else, search for the
empty location in the right subtree and insert the data.
Now, let's see the process of inserting a node into BST using an example.
(iii)Deletion in Binary Search tree
In a binary search tree, we must delete a node from the tree by keeping in mind
that the property of BST is not violated. To delete a node from BST, there are three
possible situations occur -
o The node to be deleted is the leaf node, or,
o The node to be deleted has only one child, and,
o The node to be deleted has two children
We will understand the situations listed above in detail.
When the node to be deleted is the leaf node
It is the simplest case to delete a node in BST. Here, we have to replace the leaf
node with NULL and simply free the allocated space.
We can see the process to delete a leaf node from BST in the below image. In
below image, suppose we have to delete node 90, as the node to be deleted is a leaf
node, so it will be replaced with NULL, and the allocated space will free.

When the node to be deleted has only one child

In this case, we have to replace the target node with its child, and then delete the
child node. It means that after replacing the target node with its child node, the
child node will now contain the value to be deleted. So, we simply have to replace
the child node with NULL and free up the allocated space.
We can see the process of deleting a node with one child from BST in the below
image. In the below image, suppose we have to delete the node 79, as the node to
be deleted has only one child, so it will be replaced with its child 55.
So, the replaced node 79 will now be a leaf node that can be easily deleted.

When the node to be deleted has two children

This case of deleting a node in BST is a bit complex among other two cases. In
such a case, the steps to be followed are listed as follows -
 o First, find the inorder successor of the node to be deleted.
o After that, replace that node with the inorder successor until the target node
is placed at the leaf of tree.
o And at last, replace the node with NULL and free up the allocated space.
The inorder successor is required when the right child of the node is not empty. We
can obtain the inorder successor by finding the minimum element in the right child
of the node.
We can see the process of deleting a node with two children from BST in the below
image. In the below image, suppose we have to delete node 45 that is the root
node, as the node to be deleted has two children, so it will be replaced with its
inorder successor. Now, node 45 will be at the leaf of the tree so that it can be
deleted easily.

Tree traversal (Inorder, Preorder an Postorder)

The task is to print the elements in inorder, preorder, and postorder traversal of the
Binary Search Tree.
Inorder Traversal:
At first traverse left subtree then visit the root and then traverse the right subtree.
Preorder Traversal:
At first visit the root then traverse left subtree and then traverse the right subtree.
Postorder Traversal:
At first traverse left subtree then traverse the right subtree and then visit the root.
 Graph
A Graph is a non-linear data structure that consists of vertices (nodes) and edges.

A vertex, also called a node, is a point or an object in the Graph, and an edge is
used to connect two vertices with each other.
Graphs are non-linear because the data structure allows us to have different paths
to get from one vertex to another, unlike with linear data structures like Arrays or
Linked Lists.
Graphs are used to represent and solve problems where the data consists of objects
and relationships between them, such as:
 Social Networks: Each person is a vertex, and relationships (like friendships)
are the edges. Algorithms can suggest potential friends.
 Maps and Navigation: Locations, like a town or bus stops, are stored as
vertices, and roads are stored as edges. Algorithms can find the shortest
route between two locations when stored as a Graph.
 Internet: Can be represented as a Graph, with web pages as vertices and
hyperlinks as edges.
 Biology: Graphs can model systems like neural networks or the spread of
diseases.

Graph Properties
Use the animation below to get an understanding of the different Graph properties,
and how these properties can be combined.
Weighted
Connected
Directed
Cyclic
Loop

A weighted Graph is a Graph where the edges have values. The weight value of an
edge can represent things like distance, capacity, time, or probability.
A connected Graph is when all the vertices are connected through edges somehow.
A Graph that is not connected, is a Graph with isolated (disjoint) subgraphs, or
single isolated vertices.
A directed Graph, also known as a digraph, is when the edges between the vertex
pairs have a direction. The direction of an edge can represent things like hierarchy
or flow.
A cyclic Graph is defined differently depending on whether it is directed or not:
 A directed cyclic Graph is when you can follow a path along the directed
edges that goes in circles. Removing the directed edge from F to G in the
animation above makes the directed Graph not cyclic anymore.
 An undirected cyclic Graph is when you can come back to the same vertex
you started at without using the same edge more than once. The undirected
Graph above is cyclic because we can start and end up in vertes C without
using the same edge twice.
A loop, also called a self-loop, is an edge that begins and ends on the same vertex.
A loop is a cycle that only consists of one edge. By adding the loop on vertex A in
the animation above, the Graph becomes cyclic.

Graph Representations
A Graph representation tells us how a Graph is stored in memory.
Different Graph representations can:
 take up more or less space.
 be faster or slower to search or manipulate.
 be better suited depending on what type of Graph we have (weighted,
directed, etc.), and what we want to do with the Graph.
 be easier to understand and implement than others.
Graph representations store information about which vertices are adjacent, and
how the edges between the vertices are. Graph representations are slightly different
if the edges are directed or weighted.
Two vertices are adjacent, or neighbors, if there is an edge between them.

Adjacency Matrix Graph Representation

The Adjacency Matrix is a 2D array (matrix) where each cell on index (i,j) stores
information about the edge from vertex i to vertex j.

The adjacency matrix above represents an undirected Graph, so the values '1' only
tells us where the edges are. Also, the values in the adjacency matrix is
symmetrical because the edges go both ways (undirected Graph).
Adjacency List Graph Representation
In case we have a 'sparse' Graph with many vertices, we can save space by using
an Adjacency List compared to using an Adjacency Matrix, because an Adjacency
Matrix would reserve a lot of memory on empty Array elements for edges that
don't exist.
A 'sparse' Graph is a Graph where each vertex only has edges to a small portion of
the other vertices in the Graph.
An Adjacency List has an array that contains all the vertices in the Graph, and each
vertex has a Linked List (or Array) with the vertex's edges.

Graph Traversal
(i)BFS algorithm
Breadth-first search(BFS) is a graph traversal algorithm that starts traversing the
graph from the root node and explores all the neighboring nodes. Then, it selects
the nearest node and explores all the unexplored nodes. While using BFS for
traversal, any node in the graph can be considered as the root node.
Algorithm
The steps involved in the BFS algorithm to explore a graph are given as follows -
Step 1: SET STATUS = 1 (ready state) for each node in G
Step 2: Enqueue the starting node A and set its STATUS = 2 (waiting state)
Step 3: Repeat Steps 4 and 5 until QUEUE is empty
Step 4: Dequeue a node N. Process it and set its STATUS = 3 (processed state).
Step 5: Enqueue all the neighbours of N that are in the ready state (whose
STATUS = 1) and set
their STATUS = 2
Advertisement
(waiting state)
[END OF LOOP]
Step 6: EXIT
Example of BFS algorithm
Now, let's understand the working of BFS algorithm by using an example. In the
example given below, there is a directed graph having 7 vertices.

In the above graph, minimum path 'P' can be found by using the BFS that will start
from Node A and end at Node E. The algorithm uses two queues, namely QUEUE1
and QUEUE2. QUEUE1 holds all the nodes that are to be processed, while
QUEUE2 holds all the nodes that are processed and deleted from QUEUE1.
Now, let's start examining the graph starting from Node A.
Step 1 - First, add A to queue1 and NULL to queue2.
Advertisement
1. QUEUE1 = {A}
2. QUEUE2 = {NULL}
Step 2 - Now, delete node A from queue1 and add it into queue2. Insert all
neighbors of node A to queue1.
1. QUEUE1 = {B, D}
2. QUEUE2 = {A}
Step 3 - Now, delete node B from queue1 and add it into queue2. Insert all
neighbors of node B to queue1.
1. QUEUE1 = {D, C, F}
2. QUEUE2 = {A, B}
Step 4 - Now, delete node D from queue1 and add it into queue2. Insert all
neighbors of node D to queue1. The only neighbor of Node D is F since it is
already inserted, so it will not be inserted again.
Advertisement
1. QUEUE1 = {C, F}
2. QUEUE2 = {A, B, D}
Step 5 - Delete node C from queue1 and add it into queue2. Insert all neighbors of
node C to queue1.
1. QUEUE1 = {F, E, G}
2. QUEUE2 = {A, B, D, C}
Step 5 - Delete node F from queue1 and add it into queue2. Insert all neighbors of
node F to queue1. Since all the neighbors of node F are already present, we will
not insert them again.
1. QUEUE1 = {E, G}
2. QUEUE2 = {A, B, D, C, F}
Step 6 - Delete node E from queue1. Since all of its neighbors have already been
added, so we will not insert them again. Now, all the nodes are visited, and the
target node E is encountered into queue2.
1. QUEUE1 = {G}
2. QUEUE2 = {A, B, D, C, F, E}
(ii)DFS (Depth First Search) algorithm
It is a recursive algorithm to search all the vertices of a tree data structure or a
graph. The depth-first search (DFS) algorithm starts with the initial node of graph
G and goes deeper until we find the goal node or the node with no children.
Algorithm
Step 1: SET STATUS = 1 (ready state) for each node in G
Step 2: Push the starting node A on the stack and set its STATUS = 2 (waiting
state)
Step 3: Repeat Steps 4 and 5 until STACK is empty
Step 4: Pop the top node N. Process it and set its STATUS = 3 (processed state)
Step 5: Push on the stack all the neighbors of N that are in the ready state (whose
STATUS = 1) and set their STATUS = 2 (waiting state)
[END OF LOOP]
Step 6: EXIT
Pseudocode
1. DFS(G,v) ( v is the vertex where the search starts )
2. Stack S := {}; ( start with an empty stack )
3. for each vertex u, set visited[u] := false;
4. push S, v;
5. while (S is not empty) do
6. u := pop S;
7. if (not visited[u]) then
 8. visited[u] := true;
9. for each unvisited neighbour w of uu
10. push S, w;
11. end if
12. end while
13. END DFS()
Example of DFS algorithm
Now, let's understand the working of the DFS algorithm by using an example. In
the example given below, there is a directed graph having 7 vertices.

Now, let's start examining the graph starting from Node H.

Step 1 - First, push H onto the stack.
1. STACK: H
Step 2 - POP the top element from the stack, i.e., H, and print it. Now, PUSH all
the neighbors of H onto the stack that are in ready state.
1. Print: H]STACK: A
Step 3 - POP the top element from the stack, i.e., A, and print it. Now, PUSH all
the neighbors of A onto the stack that are in ready state.
1. Print: A
2. STACK: B, D
Step 4 - POP the top element from the stack, i.e., D, and print it. Now, PUSH all
the neighbors of D onto the stack that are in ready state.
1. Print: D
2. STACK: B, F
Step 5 - POP the top element from the stack, i.e., F, and print it. Now, PUSH all the
neighbors of F onto the stack that are in ready state.
1. Print: F
2. STACK: B
Step 6 - POP the top element from the stack, i.e., B, and print it. Now, PUSH all
the neighbors of B onto the stack that are in ready state.
1. Print: B
2. STACK: C
Step 7 - POP the top element from the stack, i.e., C, and print it. Now, PUSH all
the neighbors of C onto the stack that are in ready state.
1. Print: C
2. STACK: E, G
Step 8 - POP the top element from the stack, i.e., G and PUSH all the neighbors of
G onto the stack that are in ready state.
1. Print: G
2. STACK: E
Step 9 - POP the top element from the stack, i.e., E and PUSH all the neighbors of
E onto the stack that are in ready state.
1. Print: E
2. STACK:
Now, all the graph nodes have been traversed, and the stack is empty.