Data Structure and Algorithm

Chapter Seven
Trees
Introduction

• A tree is a set of nodes and edges that connect pairs of nodes. It is

an abstract model of a hierarchical structure.

• Rooted tree has the following structure:

• One node distinguished as root.

• There is a unique path from the root to the each node.

• Every node C except the root is connected from exactly other

node P. P is C's parent, and C is one of P's children.

• The number of edges in a path is the length of the path.

 Tree Terminologies
Consider the following tree.
• Root: a node without a parent. A A
• Internal node: a node with at least one
child. A, B, F, I, J B E F G
• External (leaf) node: a node without a
child.  C, D, E, H, K, L, M, G C D H I J
• Ancestors of a node: parent, grandparent,
great-grandparent, etc of a node. K L M
Ancestors of K  A, F, I
• Descendants of a node: children,
grandchildren, great-grandchildren etc of a
node.
Descendants of F  H, I, J, K, L, M
 Contd.
• Depth of a node: number of ancestors or length of the path from the
root to the node. Depth of H  2

• Height of a tree: depth of the deepest node. 3

• Sub tree: a tree consisting of a node and its descendants.

F

H I J

K L M

• Degree: The degree of a node is the number of children it has.

• Nodes that have degree ZERO are called Leaf nodes or Terminal
nodes.
 Binary Tree
• Binary tree is a tree in which no node can have more than two
children or a tree in which each node has at most two children
called left child and right child.

• Binary tree is either empty, or it consists of a node called the root

together with two binary trees called the left sub-tree and the right
sub-tree.

Root Root Root

A A A

B C B C C

D E D E E

F E E
 Contd.
• Strictly/Full binary tree: a binary tree where each node has either 0
or 2 children.

• Balanced binary tree: a binary tree where each node except the leaf
nodes has left and right children and all the leaves are at the same
level.

• Complete binary tree: a binary tree in which the length from the
root to any leaf node is either h or h-1 where h is the height of the
tree. The deepest level should also be filled from left to right.
Representation of a Binary Tree

• Binary tree can also be represented in two ways.

1. Array representation
85
2. Linked List representation
80 90
Array representation:-
70 82 87 100
• Consider the following binary tree

• Array representation of the above binary tree is

85 80 70 82 90 87 100
Contd.
Linked Implementation:-

• In linked list representation each element is represented by a node

that has exactly two link fields called one is left pointer (leftChild)
and the other is right pointer (rightChild) and data field called data.
Declaration:-
Struct Node
{
int data;
Node*rightChild;
Node*leftChild;
};Struct node*root=NULL;

• Each edge in the drawing of a binary tree is represented by a pointer

from the parent node to child node. This pointer is placed in
appropriate link field of the parent node. Since an n element binary
tree has exactly n-1 edges.
 Binary search tree (ordered binary tree)
• A binary tree that may be empty, but if it is not empty, it satisfies the
following.

• Every node has a key and no two elements have the same key.

• The keys in the right subtree are larger than the keys in the root.

• The keys in the left subtree are smaller than the keys in the root.

• The left and the right subtrees are also binary search trees.
10

6 15

4 8 14 18

7 12 16 19

11 13
 Contd.
• Ex1: Creating a binary search tree with the following values.
10 8 15 25 22 30
• Step by step creation of a binary search tree.
Root Root Root Root

10 10 8 10 15 10 25 10

8 8 15 8 15

Root 25
22 Root
10 30 10
15
8 15
8
25
25
22 30
22
 Contd.
Ex2 : Creating a binary search tree with the following values.
14 4 15 3 9 18 16 20 7 5 17
Root
14

4 15

3 9 18

7 16 20

5 17
Because of the recursive definition of trees, it is common to
write these routines recursively.
 Operations on a Binary Search Tree
Consider the following definition of binary search tree.
struct node
{
int data;
node * leftChild, *rightChild;
};
node *root=NULL;
The following are the operations on a Binary search tree.
• Inserting a new node
• Searching an elements
• Deleting a node
• Traversing all elements
 Insertion of a new node
• When a node is inserted the definition of binary search tree should be
preserved. Suppose there is a binary search tree whose root node is
pointed by root and we want to insert a node (that stores 17) pointed
by InsNodePtr.
 Cont.

• Case 1: if there is no data in the tree (i.e. root is NULL). The node
pointed by InsNodePtr should be made the root node.

InsNodePtr root root



17 17
 Cont.
• Case 2: if there is data
• Search the appropriate position.
• Insert the node in that position

InsNodePtr root root

InsertBST() 
17 10
10

6 6 15
15

4 8 14 4 8 14 18
18

7 12 7 12 16 19
16 19

11 13 11 13 17
Implementation
void insert(int data) {
struct node *tempNode = new node;
struct node *current;
struct node *parent;
tempNode->data = data;
tempNode->leftChild = NULL;
tempNode->rightChild = NULL;
//if tree is empty
if(root == NULL) {
root = tempNode;
}else {
current = root;
parent = NULL;
while(1) {
parent = current;
//go to left of the tree
if(data < parent->data) {
current = current->leftChild;
//insert to the left
if(current == NULL) {
parent->leftChild = tempNode;
return;
}
}//go to right of the tree
else {
current = current->rightChild;
//insert to the right
if(current == NULL) {
parent->rightChild = tempNode;
return;
}
}
}
}
}
Traversing
• Binary search tree can be traversed in three ways.
• Preorder traversal - traversing binary tree in the order of
parent, left and right.
• Inorder traversal- traversing binary tree in the order of left,
parent and right.
• Postorder traversal- traversing binary tree in the order of left,
right and parent.
• Algorithms for traversing binary search tree:-
void Preorder(node *root)
1. if (t != NULL)
• print t->data;
• if (t->leftChild != NULL) Preorder(t->leftChild);
• if (t->rightChild != NULL) Preorder(t->rightChild);
2. else print “Tree Empty”.
Contd.
void Inorder(node *t)
1. if (t != NULL)
• if (t->leftChild != NULL) Preorder(t->leftChild);
• print t->data;
• if (t->rightChild != NULL) Preorder(t->rightChild);
2. else print “Tree Empty”.
Void Postorder(node *t)
1. if (t != NULL)
• if (t->leftChild != NULL) Preorder(t->leftChild);
• if (t->rightChild != NULL) Preorder(t->rightChild);
• print t->data;
2. else print “Tree Empty”
Contd. root

Example:
10

6 15

4 8 14 18

7 12 16 19

11 13 17

Preorder traversal - 10, 6, 4, 8, 7, 15, 14, 12, 11, 13, 18, 16, 17, 19

Inorder traversal - 4, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
==> Used to display nodes in ascending order.

Postorder traversal- 4, 7, 8, 6, 11, 13, 12, 14, 17, 16, 19, 18, 15, 10
 Searching
• To search a node (whose data value is Number) in a binary search
tree (whose root node is pointed by root), one of the three traversal
methods can be used. struct node* search(int data) {
struct node *current = root;
Function Call cout<<"Visiting elements: \n";

int j; while(current->data != data) {

cout<<"insert the element to be if(current != NULL)
searched"<<endl; cout<<current->data<<" ";
cin>>j; if(current->data > data) {//go to left tree
struct node * temp = search(j); current = current->leftChild;
if(temp != NULL) { }
cout<<" Element found."<< temp->data<<endl; else {//else go to right tree
} current = current->rightChild;
else { }
cout<<" Element not found\n"<<j<<endl; //not found
} if(current == NULL) {
When we search an element in a binary search
return NULL;
tree, sometimes it may be necessary for the search
function to return a pointer that points to the node }}
containing the element searched return current;
Deletion
• To delete a node (whose data value is N) from binary search tree
(whose root node is pointed by root), four cases should be
considered. When a node is deleted the definition of binary search
tree should be preserved. Consider the following binary search tree

root

10

6 14

3 8 12 18

2 4 7 9 11 13 16 19

5 15 17
1
Deletion
Case 1: Deleting a leaf node (a node having no child)
rootptr
rootptr

Delete 7 
10
10

6 14
6 14

3 8 12 18
3 8 12 18

4 9 11 16 19
16 2 13
2 4 7 9 11 13 19

15 17
17 1 5
5 15
1
Contd.
Case 2: Deleting a node having only one child
Approach 1: Deletion by merging – one of the following is done

• If the deleted node is the left child of its parent and the deleted node
has only the left child, the left child of the deleted node is made the
left child of the parent of the deleted node.

• If the deleted node is the left child of its parent and the deleted node
has only the right child, the right child of the deleted node is made
the left child of the parent of the deleted node.

• If the deleted node is the right child of its parent and the node to be
deleted has only the left child, the left child of the deleted node is
made the right child of the parent of the deleted node.

• If the deleted node is the right child of its parent and the deleted
node has only the right child, the right child of the deleted node is
made the right child of the parent of the deleted node.
Contd.
rootptr
rootptr

Delete 2 
10
10

6 14
6 14

3 8 12 18
3 8 12 18

4 9 11 16 19
16 1 13
2 4 7 9 11 13 19

15 17
17 5
5 15
1
Contd.
Approach 2: Deletion by copying- the following is done
• Copy the node containing the largest element in the left (or the smallest
element in the right) to the node containing the element to be deleted

• Delete the copied node

rootptr
rootptr

Delete 2  10
10
6 14
6 14
3 8 12 18
3 8 12 18

1 4 9 11 13 16 19
2 4 7 9 11 13 16 19
15 17
15 17 5
1 5
Contd.
Case 3: Deleting a node having two children
• Approach 1: Deletion by merging – one of the following is
done
• If the deleted node is the left child of its parent, one of the
following is done
• The left child of the deleted node is made the left child of the
parent of the deleted node, and

• The right child of the deleted node is made the right child of the
node containing largest element in the left of the deleted node
OR
• The right child of the deleted node is made the left child of the
parent of the deleted node, and

• The left child of the deleted node is made the left child of the
node containing smallest element in the right of the deleted node
Contd.
• If the deleted node is the right child of its parent, one of the
following is done

• The left child of the deleted node is made the right child of the
parent of the deleted node, and

• The right child of the deleted node is made the right child of the
node containing largest element in the left of the deleted node
OR
• The right child of the deleted node is made the right child of the
parent of the deleted node, and

• The left child of the deleted node is made the left child of the
node containing smallest element in the right of the deleted node
Contd. rootptr rootptr

Delete 6 
10 10

6 14 8 14

3 8 12 18 7 9 12 18

2 4 7 9 11 13 16 19 11 13 16 19
3
15 17 15 17
1 5 4
2
rootptr
rootptr
1 5

Delete 6  10
10
3 14
6 14
2 4 12 18
3 8 12 18
5 11 13 16 19
1
2 4 7 9 11 13 16 19
8 15 17
15 17
1 5
7 9
 50

40 70

30 72
46 60

28
34 44 58 76
68

36 74 78
66
Contd.
• Approach 2: Deletion by copying- the following is done
• Copy the node containing the largest element in the left (or the
smallest element in the right) to the node containing the element to be
deleted
• Delete the copied node
rootptr rootptr

Delete 6 
10 10

6 14 5 14

3 8 12 18 3 8 12 18

4 7 9 11 13 16 19 4 7 9 11 13 16 19
2 2

15 17 15 17
1 5 1
Contd. rootptr

10

6 Delete 6  14

3 8 12 18

2 4 7 9 11 13 16 19

15 17
1 5

rootptr

10

7 14

3 8 12 18

2 4 9 11 13 16 19

5 15 17
1
Contd.
Case 4: Deleting the root node, 10
Approach 1: Deletion by merging- one of the following is
done
If the tree has only one node the root node pointer is made to point
to nothing (NULL)
If the root node has left child
the root node pointer is made to point to the left child
the right child of the root node is made the right child of the
node containing the largest element in the left of the root node
If root node has right child
the root node pointer is made to point to the right child
the left child of the root node is made the left child of the node
containing the smallest element in the right of the root node
 rootptr rootptr
Contd.
rootptr
10 Delete 10  6

6 14 3 8

3 8 12 18 2 4 7 9

2 4 7 9 11 13 16 19 5 14
1

5 15 17 12
1 18

11 13 16 19

15 17
rootptr rootptr
rootptr
10 14
Delete 10 
6 14 12 18

3 8 12 18 11 16 19
13

2 4 7 9 11 13 16 19 6 15 17

5 15 17 3 8
1

2 4 7 9

1 5
 Contd.
• Approach 2: Deletion by copying- the following is done
• Copy the node containing the largest element in the left (or the smallest
element in the right) to the node containing the element to be deleted
• Delete the copied node

rootptr
rootptr

Delete 10  9
10
6 14
6 14

3 8 12 18
3 8 12 18

2 4 7 11 13 16 19
2 4 7 9 11 13 16 19
15 17
15 17 1 5
1 5
Contd.

rootptr
rootptr

11
10 Delete 10 

6 14
6 14

3 8 12 18
3 8 12 18

4 7 9 16 19
16 2 13
2 4 7 9 11 13 19

15 17
17 1 5
5 15
1
Implementation
void DeleteBST(node *root, node *PDNP, int x)
{
node *DNP; // a pointer that points to the currently deleted node
// PDNP is a pointer that points to the parent node of currently deleted node
if(root==NULL)
cout<<"Data not found\n";
else if (root->data>x)
DeleteBST(root->leftChild, root, x);// delete the element in the left subtree
else if(root->data<x)
DeleteBST(root->rightChild, root, x);// delete the element in the right subtree
else
{
DNP=root;
if((DNP->leftChild==NULL) && (DNP->rightChild==NULL))
{
if (PDNP->leftChild==DNP)
PDNP->leftChild=NULL;
else
PDNP->rightChild=NULL;
delete DNP;
}
Implementation
else //find the minimum in the right
else {
{ if(DNP->leftChild!=NULL)
//find the maximum in the left PDNP=DNP;
{
PDNP=DNP; DNP=DNP->rightChild;
DNP=DNP->leftChild;
while(DNP->rightChild!=NULL) while(DNP->leftChild!=NULL)
{ {
PDNP=DNP;
DNP=DNP->rightChild; PDNP=DNP;
}
root->data=DNP->data; DNP=DNP->leftChild;
DeleteBST(DNP,PDNP,DNP->data); }
} root->data=DNP->data;

DeleteBST(DNP,PDNP,DNP->data);
}
}
}
}
 Application of Tree

Tree has many applications.

• File system maintenance

• Expression evaluation

• Compiler design

• To implement the shortest path problems. Etc,.

• There are many applications for trees . One of the popular uses is
the directory structure in many common operating systems
including UNIX, DOS and Windows
Tree Full Implementation
EX.

• Write a single C++ program that implements all the operations

on a tree.

Tree FIM 1.cpp