NON LINEAR DATA

STRUCTURE- TREES
Unit-4
NON LINEAR DATA STRUCTURES
🞆 In non-linear data structure, the data values
are not arranged in order and a data item is
connected to several other data items.
🞆 It uses memory efficiently. Free contiguous
memory is not required for allocating data
items.
🞆 Examples-
⚫ Trees and Graphs.
TREES
🞆 Tree is a hierarchical data structure which stores
the information naturally in the form of hierarchy
style.
🞆 Tree is one of the most powerful and advanced
data structures.
🞆 It is a non-linear data structure compared to
arrays, linked lists, stack and queue.
🞆 It represents the nodes connected by edges.
🞆 Tree is a collection of elements called Nodes,
where each node can have arbitrary number of
children.
 EXAMPLE Roo
t

A Level -
0

Level -
B C 1

Parent
Node D E F G Level -
2
Child
Node H I Sibling Level -
s 3
Subtre
e

Leaf
Node
🞆 The above figure represents structure of a tree.
Tree has 2 subtrees.

⚫ A is a parent of B and C.
⚫ B is called a child of A and
⚫ B is also parent of D and E
IMPORTANT TERMS
🞆 Path − Path refers to the sequence of nodes along the edges of a tree.
🞆 Root − The node at the top of the tree is called root. There is only one
root per tree and one path from the root node to any node.
🞆 Parent − Any node except the root node has one edge upward to a
node called parent.
🞆 Child − The node below a given node connected by its edge downward
is called its child node.
🞆 Leaf − The node which does not have any child node is called the leaf
node.
🞆 Subtree − Subtree represents the descendants of a node.
🞆 Visiting − Visiting refers to checking the value of a node when control
is on the node.
🞆 Traversing − Traversing means passing through nodes in a specific
order.
🞆 Levels − Level of a node represents the generation of a node. If the
root node is at level 0, then its next child node is at level 1, its
grandchild is at level 2, and so on.
🞆 keys − Key represents a value of a node based on which a search
operation is to be carried out for a node.
BINARY TREE
🞆 A tree whose elements have at most 2 children
is called a binary tree.
🞆 Since each element in a binary tree can have
only 2 children, we typically name them the left
child and right child.
🞆 A tree is represented by a pointer to the
topmost node in tree.
🞆 If the tree is empty, then value of root is NULL.
🞆 A Tree node contains following parts.
1. Data
2. Pointer to left child
3. Pointer to right child
STRUCTURE OF NODE IN TREES
struct node
{
int data;
struct node *left;
struct node *right;
};
TRAVERSAL IN TREES
🞆 Traversal is a process to visit all the nodes of
a tree print their values.
🞆 Because, all nodes are connected via edges
(links) we always start from the root (head)
node.
🞆 We cannot randomly access a node in a tree.
🞆 There are three ways to traverse a tree −
⚫ Pre-order Traversal
⚫ In-order Traversal
⚫ Post-order Traversal
PRE-ORDER TRAVERSAL
DATA- LEFT- RIGHT (DLR)

🞆 In this traversal method,

⚫ the root node is visited first,
⚫ then the left subtree and
⚫ finally the right subtree.
🞆 We should always remember that every node
may represent a subtree itself.
🞆 Examples solved in notebook
SAMPLE EXAMPLE

🞆 We start from A, and following pre-order traversal,

we first visit A itself and then move to its left
subtree B.
🞆 B is also traversed pre-order.
🞆 The process goes on until all the nodes are visited.
🞆 The output of pre-order traversal of this tree will be
−

A→B→D→E→C→F→G
ALGORITHM &FUNCTION (RECURSIVE)
Algorithm
Until all nodes are traversed −
🞆 Step 1 − Visit root node.

🞆 Step 2 − Recursively traverse left subtree. (Preorder left-

subtree)
🞆 Step 3 − Recursively traverse right subtree. (Preorder right-
subtree)

Function
void preorder( struct node *tnode)
{
if(tnode)
{
printf(“%d”, & tnode->data);
preorder(tnode->leftchild);
preorder(tnode->rightchild);
}
}
NON RECURSIVE FUNCTION-PREORDER
void preorder(struct btreenode *root )
{
while(isempty(&stk))
{
push(&stk, root);
while(root!=NULL)
{
//Print data
printf(“%d”, root->data);
//Push right value into stack
push(&stk, root->right);
//Move to left
root=root->left;
}
if(isempty)
return;
root=pop(&stk);
}
IN-ORDER TRAVERSAL
LEFT- DATA- RIGHT (LDR)

🞆 In this traversal method,

⚫ the left subtree is visited first,
⚫ then the root and
⚫ later the right sub-tree.
🞆 We should always remember that every node
may represent a subtree itself.
🞆 If a binary tree is traversed in-order, the
output will produce sorted key values in an
ascending order.
🞆 Examples solved in notebook
SAMPLE EXAMPLE

🞆 We start from A, and following In-order traversal,

we first visit node A itself and then the left
subtree B.
🞆 B is also traversed In-order.
🞆 The process goes on until all the nodes are visited.
🞆 The output of In-order traversal of this tree will be −

D→B→E→A→F→C→G
ALGORITHM &FUNCTION (RECURSIVE)
Algorithm
Until all nodes are traversed −
🞆 Step 1 − Recursively traverse left subtree. (Inorder left-subtree)

🞆 Step 2 − Visit root node.

🞆 Step 3 − Recursively traverse right subtree. (Inorder right-

subtree)

Function
void inorder( struct node *tnode)
{
if(tnode)
{
inorder(tnode->leftchild);
printf(“%d”, & tnode->data);
inorder(tnode->rightchild);
}
}
NON RECURSIVE FUNCTION-INORDER
void inorder(struct btreenode *root )
{
while(isempty(&stk))
{
push(&stk, root);
while(root!=NULL)
{
push(&stk, root->left);
root=root->left;
}
if(isempty)
return;
root=pop(&stk);
printf(“%d”, root->data);
root=root->right;
}
}
POST-ORDER TRAVERSAL
LEFT – RIGHT - DATA (LRD)

🞆 In this traversal method,

⚫ the left subtree is traversed first and
⚫ Then the right subtree
⚫ And finally the root node is visited

🞆 We should always remember that every node

may represent a subtree itself.

🞆 Examples solved in notebook

SAMPLE EXAMPLE

🞆 We start from A, and following post-order traversal,

we first visit left sub-tree of A and then right subtree
of A
🞆 B is also traversed post-order.
🞆 The process goes on until all the nodes are visited.
🞆 The output of post-order traversal of this tree will be
−

D→E→B→F→G→C→A
 ALGORITHM & FUNCTION (RECURSIVE)
Algorithm
Until all nodes are traversed −
🞆 Step 1− Recursively traverse left subtree. (Postorder left-subtree)

🞆 Step 2 − Recursively traverse right subtree. (Postorder right-

subtree)
🞆 Step 3 − Visit root node

Function
void postorder( struct node *tnode)
{
if(tnode)
{
postorder(tnode->leftchild);
postorder(tnode->rightchild);
printf(“%d”, & tnode->data);
}
}
NON RECURSIVE FUNCTION-POSTORDER
void postorder(struct btreenode *root )
{
while(isempty(&stk)
{
while(root!=NULL)
{
//Push the right
push(&stk, -(root->right));
//Move to left
root=root->left;
push(&stk, root->left);
}
if(isempty)
return;
root=pop(&stk);
if (root>0)
printf(“%d”, root->data);
else
push(&stk, -(root));
}
TYPES OF BINARY TREES
🞆 Full Binary Tree
🞆 Complete Binary Tree
🞆 Binary Search Tree
🞆 Expression Tree
FULL BINARY TREE
🞆 A full binary tree (sometimes proper binary
tree or 2-tree) is a tree in which every node
other than the leaves has two children.
COMPLETE BINARY TREE

🞆 A Binary Tree is complete Binary Tree if all

levels are completely filled except possibly
the last level
🞆 The last level has all keys as left as possible
BINARY SEARCH TREE

🞆 A Binary Search Tree (BST) is a tree in which all

the nodes follow the below-mentioned properties
−
⚫ The left sub-tree of a node has a key less than or
equal to its parent node's key.
⚫ The right sub-tree of a node has a key greater than to
its parent node's key.
🞆 Thus, BST divides all its sub-trees into two
segments; the left sub-tree and the right sub-
tree and can be defined as −

left_subtree (keys) ≤ node (key) ≤ right_subtree

(keys)
REPRESENTATION
🞆 BST is a collection of nodes arranged in a way
where they maintain BST properties.
🞆 Each node has a key and an associated value.
🞆 In figure below we observe that the root node key
(27) has
⚫ all lower-valued keys on the left sub-tree and
⚫ the higher valued keys on the right sub-tree.
BASIC OPERATIONS ON BINARY SEARCH TREES

🞆 Search − Searches an element in a tree.

🞆 Insert − Inserts an element in a tree.
🞆 Delete − Deletes an element in a tree.
🞆 Pre-order Traversal − Traverses a tree in a pre-
order manner.
🞆 In-order Traversal − Traverses a tree in an in-
order manner.
🞆 Post-order Traversal − Traverses a tree in a
post-order manner.
SEARCH OPERATION

🞆 Whenever an element is to be searched, start

searching from the root node.
🞆 If the data is less than the key value, search
for the element in the left subtree.
🞆 Otherwise, search for the element in the right
subtree.
🞆 Follow the same algorithm for each node.
INSERT OPERATION
🞆 Whenever an element is to be inserted, first
locate its proper location.
🞆 Start searching from the root node, then if
the data is less than the key value, search for
the empty location in the left subtree and
insert the data.
🞆 Otherwise, search for the empty location in
the right subtree and insert the data.
🞆 Examples in notebook
DELETE OPERATION
🞆 In deletion process, there are 4 possible
conditions-
1. Data not present in the tree
2. The node containing data has no child nodes
3. The node containing data has exactly one child
4. The node containing data has exactly two children

🞆 Case-1
⚫ Print the message “Data required is not present”
🞆 Case-2
⚫ Free the memory occupied by the node to be deleted
⚫ Either left or right link of parent node(where node to
be deleted is attached) is set to NULL
CONTD..
🞆 Case-3
⚫ Adjust the pointer of the parent of the node to be
deleted such that after deletion it points to the
child of the node

🞆 Case-4
⚫ The inorder successor of the node to be deleted
occupies its place and is deleted from its original
location
FUNCTION TO INSERT IN BINARY SEARCH TREE
void insert(struct btreenode*, int num)
{
struct node *new= malloc(sizeof (struct node));
new->left=NULL;
new->data=num;
new->right=NULL;

if(root==NULL)
root=new;
else
{
if(num<root)
insert(root->left, num)
else
insert(root->right, num)
}
}
FUNCTION TO DELETE A NODE IN BINARY
SEARCH TREE
void delete(struct btreenode*, int num)
{
struct btreenode *parent, *x, *xsucc;
if(root==NULL)
printf(“Tree is empty”);
else
search(int num);

//If the node to be deleted has no child

if(x->left==NULL && x->right==NULL)
{
if(parent->right==x)
parent->right==NULL;
else
parent->left==NULL;
free(x);
}
//If the node to be deleted has one child node
if(x->left!=NULL && x->right==NULL)
{
if(parent->right==x)
parent->right==x->left;
else
parent->left==x->left;
free(x);
}
if(x->left==NULL && x->right!=NULL)
{
if(parent->right==x)
parent->right==x->right;
else
parent->left==x->right;
free(x);
}
//If the node to be deleted has two children
if(x->left!=NULL && x->right!=NULL)
{
parent=x;
xsucc=x->right;
while(x->left!=NULL)
{
parent=xsucc;
xsucc=xsucc->left;
}
x->data=xsucc->data
free(xsucc);
}
FUNCTION TO SEARCH BINARY SEARCH TREE
Void search(struct btreenode*, int num)
{
struct btreenode *q;
q=root;
while(q!=NULL)
{
if(q->data=num)
{
*x=q;
return;
}
else
{
id(q->data >num)
q=q->left;
else
q=q->right;
}
}
}
THREADED BINARY TREES
🞆 When a binary tree is represented using linked list
representation, the reference part of the node
which doesn't have a child is filled with NULL
pointer.
🞆 In any binary tree linked list representation, there
are more number of NULL pointers than actual
pointers.
🞆 Generally, in any binary tree linked list
representation, if there are 2N number of
reference fields, then N+1 number of reference
fields are filled with NULL ( N+1 are NULL out
of 2N ).
🞆 This NULL pointer does not play any role except
indicating that there is no link (no child).
🞆 Threaded Binary Tree", makes use of NULL
pointers to improve its traversal process. In
threaded binary tree, NULL pointers are replaced
by references of other nodes in the tree.
🞆 These extra references are called as threads.
🞆 The idea is to make all left child pointers that are
NULL (in Linked list representation) points to its
in-order predecessor, and all right child pointers
that are NULL (in Linked list representation)
points to its in-order successor.
🞆 If there is no in-order predecessor or in-order
successor, then it points to the root node.
🞆 Consider the following binary tree...

🞆 To convert the above example binary tree into

threaded binary tree, first find the in-order
traversal of that tree...
🞆 In-order traversal of above binary tree...
H-D-I-B-E-A-F-J-C-G
🞆 When we represent the above binary tree using
linked list representation, nodes H, I, E, F,
J and G left child pointers are NULL.
🞆 This NULL is replaced by address of its in-order
predecessor respectively (I to D, E to B, F to A, J
to F and G to C),
🞆 But here the node H does not have its in-order
predecessor, so it points to the root node A.
🞆 Nodes H, I, E, J and G right child pointers are
NULL.
🞆 This NULL pointers are replaced by address of its
in-order successor respectively (H to D, I to B, E
to A, and J to C),
🞆 But here the node G does not have its in-order
successor, so it points to the root node A.
🞆 Above example binary tree is converted into
threaded binary tree as follows.
THREADED BINARY TREE
LINKED REPRESENTATION
EXPRESSION TREES
🞆 Expression tree is a binary tree in which
⚫ each internal node corresponds to operator and
⚫ each leaf node corresponds to operand
🞆 Example – Expression-> 3 + ((5+9)*2)
CONSTRUCTION OF EXPRESSION
TREE
🞆 Calculate postfix of the given expression
🞆 If character is operand push that into stack
🞆 If character is operator pop two values from stack
make them its child and push current node again.
🞆 At the end only element of stack will be root of
expression tree.
🞆 Inorder traversal of expression tree produces infix
version of the expression
🞆 Post order traversal of expression tree produces
postfix version
🞆 Preorder traversal of expression tree produces
prefix version
🞆 Construct expression tree for the following-
⚫a + b - e * f * g
HEIGHT BALANCED TREES (AVL
TREES)
🞆 If the input to binary search tree comes in a
sorted (ascending or descending) manner the
tree will then look either left aligned or right
aligned (unbalanced)
🞆 AVL tree is a self-balancing Binary Search Tree
(BST) where the difference between heights of left
and right subtrees cannot be more than one for
all nodes.
🞆 This difference is called the Balance Factor.
🞆 BalanceFactor = height(left-sutree) −
height(right-sutree)
🞆 If the difference in the height of left and right sub-
trees is more than 1, the tree is balanced using
some rotation techniques.
AVL ROTATIONS
🞆 To balance itself, an AVL tree may perform
the following four kinds of rotations −
🞆 Left rotation
🞆 Right rotation
🞆 Left-Right rotation
🞆 Right-Left rotation
🞆 The first two rotations are single rotations
and the next two rotations are double
rotations.
🞆 To have an unbalanced tree, we at least need
a tree of height 2.
LEFT ROTATION
🞆 If a tree becomes unbalanced, when a node is inserted into
the right subtree of the right subtree, then we perform a
single left rotation −

🞆 Node A has become unbalanced as a node is inserted in the

right subtree of A's right subtree.
🞆 We perform the left rotation by making A the left-subtree of
RIGHT ROTATION

🞆 AVL tree may become unbalanced, if a node

is inserted in the left subtree of the left
subtree. The tree then needs a right rotation.

🞆 the unbalanced node becomes the right child

of its left child by performing a right rotation.
LEFT-RIGHT ROTATION

🞆 A left-right rotation is a combination of left

rotation followed by right rotation.
🞆 A node has been inserted into the right subtree of
the left subtree.
🞆 This makes C an unbalanced node.
🞆 These scenarios cause AVL tree to perform left-
right rotation.
 1 2

We first perform the left Node C is still unbalanced,

rotation on the left subtree however now, it is because
of C. This makes A, the of the left-subtree of the
left subtree of B. left-subtree.

3 4

We shall now right-rotate the tree, The tree is now

making B the new root node of this balanced.
subtree. C now becomes the right
subtree of its own left subtree.
RIGHT-LEFT ROTATION
🞆 The second type of double rotation is Right-
Left Rotation.
🞆 It is a combination of right rotation followed
by left rotation.
🞆 A node has been inserted into the left
subtree of the right subtree. This makes A,
an unbalanced node with balance factor 2.
First, we perform the right
rotation along C node, Node A is still unbalanced
making C the right subtree of its because of the right subtree of
own left subtree B. its right subtree and requires a
Now, B becomes the right left rotation.
subtree of A.

A left rotation is performed by

The tree is now
making B the new root node of the
balanced.
subtree. A becomes the left subtree
of its right subtree B.
AVL
🞆 Examples solved in notebook