TREES

General trees – Terminology – Representation of trees – Tree traversal- Binary tree – Representation
– Expression tree – Binary tree traversal - Threaded Binary Tree - Binary Search Tree – Construction
- Searching - Binary Search Tree- Insertion – Deletion - AVL trees – Rotation AVL trees – Insertion –
Deletion - B-Trees – Splay trees - Red-Black Trees

Binary Tree

 In a normal tree, every node can have any number of children. Binary tree is a special
type of tree data structure in which every node can have a maximum of 2 children.
One is known as left child and the other is known as right child.
 A tree in which every node can have a maximum of two children is called as
Binary Tree.
 In a binary tree, every node can have either 0 children or 1 child or 2 children but not
more than 2 children.

Example

There are different types of binary trees and they are...

1. Strictly Binary Tree

In a binary tree, every node can have a maximum of two children. But in strictly binary tree,
every node should have exactly two children or none. That means every internal node must
have exactly two children. A strictly Binary Tree can be defined as follows...

A binary tree in which every node has either two or zero number of children is called
Strictly Binary Tree

Strictly binary tree is also called as Full Binary Tree or Proper Binary Tree or 2-Tree

Strictly binary tree data structure is used to represent mathematical expressions.

Example

2. Complete Binary Tree

In a binary tree, every node can have a maximum of two children. But in strictly binary tree,
every node should have exactly two children or none and in complete binary tree all the
nodes must have exactly two children and at every level of complete binary tree there must
be 2level number of nodes. For example at level 2 there must be 22 = 4 nodes and at level 3
there must be 23 = 8 nodes.

A binary tree in which every internal node has exactly two children and all leaf nodes
are at same level is called Complete Binary Tree.
Complete binary tree is also called as Perfect Binary Tree

3. Extended Binary Tree

A binary tree can be converted into Full Binary tree by adding dummy nodes to existing
nodes wherever required.

The full binary tree obtained by adding dummy nodes to a binary tree is called as
Extended Binary Tree.

In above figure, a normal binary tree is converted into full binary tree by adding dummy
nodes (In pink colour).
Binary Tree Representations

A binary tree data structure is represented using two methods. Those methods are as
follows...

 Array Representation
 Linked List Representation

Consider the following binary tree...

1. Array Representation

In array representation of binary tree, we use a one dimensional array (1-D Array) to
represent a binary tree.

Consider the above example of binary tree and it is represented as follows...

To represent a binary tree of depth 'n' using array representation, we need one dimensional
array with a maximum size of 2n+1 - 1.

It is found that if n is the number or index of a node, then its left child occurs at (2n +
1)th position & right child at (2n + 2) th position of the array. If any node does not have any
of its child, then null value is stored at the corresponding index of the array.
2. Linked List Representation

We use double linked list to represent a binary tree. In a double linked list, every node
consists of three fields. First field for storing left child address, second for storing actual data
and third for storing right child address.

In this linked list representation, a node has the following structure...

Struct node
{
struct node * lc;
int data;
struct node * rc;
};
Creating TREE

struct node * buildtree(int n);

{ struct node *

temp=NULL; if( a[n] != NULL)

{ temp = (struct node *) malloc(sizeof(struct node));

temp-> lc=buildtree(2n + 1);

temp-> data= a[n];

temp-> rc=buildtree(2n + 2);

} return temp;

}
The above example of binary tree represented using Linked list representation is shown as
follows...

Binary Tree Traversals

In any binary tree displaying order of nodes depends on the traversal method.

Displaying (or) visiting order of nodes in a binary tree is called as Binary Tree Traversal.

There are three types of binary tree traversals.

1. In - Order Traversal
2. Pre - Order Traversal
3. Post - Order

Traversal In-order

Traversal

Until all nodes are traversed −

 Step 1 − Recursively traverse left subtree.

 Step 2 − Visit root node.
 Step 3 − Recursively traverse right subtree.
Algorithm
The algorithm for inorder traversal is as follows.

void inorder(struct node * root);

{
if(root != NULL)
{
inorder(roo-> lc);
printf("%d\t",root->data);
inorder(root->rc);
}
}

Consider the following binary tree...

In In-Order traversal, the root node is visited between left child and right child. In this
traversal, the left child node is visited first, then the root node is visited and later we go for
visiting right child node. This in-order traversal is applicable for every root node of all
subtrees in the tree. This is performed recursively for all nodes in the tree.

In the above example of binary tree, first we try to visit left child of root node 'A', but A's left
child is a root node for left subtree. so we try to visit its (B's) left child 'D' and again D is a
root for subtree with nodes D, I and J. So we try to visit its left child 'I' and it is the left most
child. So first we visit 'I' then go for its root node 'D' and later we visit D's right child 'J'. With
this we have completed the left part of node B. Then visit 'B' and next B's right child 'F' is
visited. With this we have completed left part of node A. Then visit root node 'A'. With this
we have completed left and root parts of node A. Then we go for right part of the node A. In
right of A again there is a subtree with root C. So go for left child of C and again it is a
subtree with root G. But G does not have left part so we visit 'G' and then visit G's right child
K. With this we have completed the left part of node C. Then visit root node 'C' and next visit
C's right child 'H' which is the right most child in the tree so we stop the process.

That means here we have visited in the order of I - D - J - B - F - A - G - K - C - H using In-

Order Traversal.

In-Order Traversal for above example of binary tree is

I-D-J-B-F-A-G-K-C-H

2. Pre-Order Traversal

Until all nodes are traversed −

 Step 1 − Visit root node.

 Step 2 − Recursively traverse left subtree.
 Step 3 − Recursively traverse right subtree.

void preorder(struct node * root);

{
if(root != NULL)
{
printf("%d\t",root->data);
preorder(root-> lc);
preorder(root->rc);
}
}

Consider the following binary tree...

In Pre-Order traversal, the root node is visited before left child and right child nodes. In this
traversal, the root node is visited first, then its left child and later its right child. This pre-
order traversal is applicable for every root node of all subtrees in the tree.

In the above example of binary tree, first we visit root node 'A' then visit its left
child 'B' which is a root for D and F. So we visit B's left child 'D' and again D is a root for I
and J. So we visit D's left child 'I' which is the left most child. So next we go for visiting D's
right child 'J'. With this we have completed root, left and right parts of node D and root, left
parts of node B. Next visit B's right child 'F'. With this we have completed root and left parts
of node A. So we go for A's right child 'C' which is a root node for G and H. After visiting C,
we go for its left child 'G' which is a root for node K. So next we visit left of G, but it does not
have left child so we go for G's right child 'K'. With this we have completed node C's root
and left parts. Next visit C's right child 'H' which is the right most child in the tree. So we
stop the process.

That means here we have visited in the order of A-B-D-I-J-F-C-G-K-H using Pre-Order
Traversal.

Pre-Order Traversal for above example binary tree is

A-B-D-I-J-F-C-G-K-H
Post-order Traversal

Until all nodes are traversed −

 Step 1 − Recursively traverse left subtree.

 Step 2 − Recursively traverse right subtree.
 Step 3 − Visit root node.

void postorder(struct node * root);

{
if(root != NULL)
{
postorder(root-> lc);
postorder(root->rc);
printf("%d\t",root->data);
}
}

Consider the following binary tree...

In Post-Order traversal, the root node is visited after left child and right child. In this
traversal, left child node is visited first, then its right child and then its root node. This is
recursively performed until the right most node is visited.
Here we have visited in the order of I - J - D - F - B - K - G - H - C - A using Post-Order
Traversal.

Post-Order Traversal for above example binary tree is

I-J-D-F-B-K-G-H-C–A

Threaded Binary Tree

A binary tree is represented using array representation or linked list representation. When a
binary tree is represented using linked list representation, if any node is not having a child
we use NULL pointer in that position. In any binary tree linked list representation, there are
more number of NULL pointer 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 there is no link (no child).

A. J. Perlis and C. Thornton have proposed new binary tree called "Threaded Binary Tree",
which make use of NULL pointer to improve its traversal processes. In threaded binary tree,
NULL pointers are replaced by references to other nodes in the tree, called threads.

Threaded Binary Tree is also a binary tree in which 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 point to root node.

Consider the following binary tree...

To convert above 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 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. And 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 become as follows after
converting into threaded binary tree.

In above figure threads are indicated with dotted links.

Binary Search Tree
In a binary tree, every node can have maximum of two children but there is no order of
nodes based on their values. In binary tree, the elements are arranged as they arrive to the
tree, from top to bottom and left to right.

A binary tree has the following time complexities...

1. Search Operation - O(n)

2. Insertion Operation - O(1)
3. Deletion Operation - O(n)

To enhance the performance of binary tree, we use special type of binary tree known
as Binary Search Tree. Binary search tree mainly focus on the search operation in binary tree.
Binary search tree can be defined as follows...

Binary Search Tree is a binary tree in which every node contains only smaller values in its
left subtree and only larger values in its right subtree.

In a binary search tree, all the nodes in left subtree of any node contains smaller values and
all the nodes in right subtree of that contains larger values as shown in following figure...

Example

The following tree is a Binary Search Tree. In this tree, left subtree of every node contains
nodes with smaller values and right subtree of every node contains larger values.
 Every Binary Search Tree is a binary tree but all the Binary Trees need not to be binary
search trees.

Operations on a Binary Search Tree

The following operations are performed on a binary earch tree...

1. Search
2. Insertion
3. Deletion

Search Operation in BST

In a binary search tree, the search operation is performed with O(log n) time complexity. The
search operation is performed as follows...

 Step 1: Read the search element from the user

 Step 2: Compare, the search element with the value of root node in the tree.

 Step 3: If both are matching, then display "Given node found!!!" and terminate the

function

 Step 4: If both are not matching, then check whether search element is smaller or

larger than that node value.

 Step 5: If search element is smaller, then continue the search process in left subtree.

 Step 6: If search element is larger, then continue the search process in right subtree.

 Step 7: Repeat the same until we found exact element or we completed with a leaf

node

 Step 8: If we reach to the node with search value, then display "Element is found" and

terminate the function.

 Step 9: If we reach to a leaf node and it is also not matching, then display "Element not

found" and terminate the function.

Insertion Operation in BST

In a binary search tree, the insertion operation is performed with O(log n) time complexity.
In binary search tree, new node is always inserted as a leaf node. The insertion operation is
performed as follows...

 Step 1: Create a newNode with given value and set its left and right to NULL.

 Step 2: Check whether tree is Empty.

 Step 3: If the tree is Empty, then set set root to newNode.

 Step 4: If the tree is Not Empty, then check whether value of newNode

is smaller or larger than the node (here it is root node).

 Step 5: If newNode is smaller than or equal to the node, then move to its left child. If

newNode is larger than the node, then move to its right child.

 Step 6: Repeat the above step until we reach to a leaf node (e.i., reach to NULL).

 Step 7: After reaching a leaf node, then isert the newNode as left child if newNode

is smaller or equal to that leaf else insert it asright child.

Deletion Operation in BST

In a binary search tree, the deletion operation is performed with O(log n) time complexity.
Deleting a node from Binary search tree has follwing three cases...

 Case 1: Deleting a Leaf node (A node with no children)

 Case 2: Deleting a node with one child
 Case 3: Deleting a node with two children

Case 1: Deleting a leaf node

We use the following steps to delete a leaf node from BST...

 Step 1: Find the node to be deleted using search operation

 Step 2: Delete the node using free function (If it is a leaf) and terminate the function.

Case 2: Deleting a node with one child

We use the following steps to delete a node with one child from BST...

 Step 1: Find the node to be deleted using search operation

 Step 2: If it has only one child, then create a link between its parent and child nodes.

 Step 3: Delete the node using free function and terminate the function.

Case 3: Deleting a node with two children

We use the following steps to delete a node with two children from BST...

 Step 1: Find the node to be deleted using search operation

 Step 2: If it has two children, then find the largest node in its left subtree (OR)

the smallest node in its right subtree.

 Step 3: Swap both deleting node and node which found in above step.

 Step 4: Then, check whether deleting node came to case 1 or case 2 else goto steps 2

 Step 5: If it comes to case 1, then delete using case 1 logic.

 Step 6: If it comes to case 2, then delete using case 2 logic.

 Step 7: Repeat the same process until node is deleted from the tree.

Example

Construct a Binary Search Tree by inserting the following sequence of numbers...

10,12,5,4,20,8,7,15 and 13

Above elements are inserted into a Binary Search Tree as follows..

AVL Tree

AVL tree is a self balanced binary search tree. That means, an AVL tree is also a binary search
tree but it is a balanced tree. A binary tree is said to be balanced, if the difference between the
hieghts of left and right subtrees of every node in the tree is either -1, 0 or +1. In other words,
a binary tree is said to be balanced if for every node, height of its children differ by at most
one. In an AVL tree, every node maintains a extra information known as balance factor. The
AVL tree was introduced in the year of 1962 by Adelson-Velsky and Landis.

An AVL tree is defined as follows...

An AVL tree is a balanced binary search tree. In an AVL tree, balance factor of every node
is either -1, 0 or +1.

Balance factor of a node is the difference between the heights of left and right subtrees of
that node. The balance factor of a node is calculated either height of left subtree - height of
right subtree (OR) height of right subtree - height of left subtree. In the following
explanation, we are calculating as follows...

Balance factor = heightOfLeftSubtree - heightOfRightSubtree

Example

The above tree is a binary search tree and every node is satisfying balance factor condition.
So this tree is said to be an AVL tree.
Every AVL Tree is a binary search tree but all the Binary Search Trees need not to be AVL
trees.

AVL Tree Rotations

In AVL tree, after performing every operation like insertion and deletion we need to check
the balance factor of every node in the tree. If every node satisfies the balance factor
condition then we conclude the operation otherwise we must make it balanced. We
use rotation operations to make the tree balanced whenever the tree is becoming imbalanced
due to any operation. Rotation operations are used to make a tree balanced.

Rotation is the process of moving the nodes to either left or right to make tree balanced.
There are four rotations and they are classified into two types.

Single Left Rotation (LL Rotation)

In LL Rotation every node moves one position to left from the current position. To
understand LL Rotation, let us consider following insertion operations into an AVL Tree...
Single Right Rotation (RR Rotation)

In RR Rotation every node moves one position to right from the current position. To
understand RR Rotation, let us consider following insertion operations into an AVL Tree...

Left Right Rotation (LR Rotation)

The LR Rotation is combination of single left rotation followed by single right rotation. In LR
Rotation, first every node moves one position to left then one position to right from the
current position. To understand LR Rotation, let us consider following insertion operations
into an AVL Tree...
Right Left Rotation (RL Rotation)

The RL Rotation is combination of single right rotation followed by single left rotation. In RL
Rotation, first every node moves one position to right then one position to left from the
current position. To understand RL Rotation, let us consider following insertion operations
into an AVL Tree...

Operations on an AVL Tree

The following operations are performed on an AVL tree...

1. Search
2. Insertion
3. Deletion

Search Operation in AVL Tree

In an AVL tree, the search operation is performed with O(log n) time complexity. The search
operation is performed similar to Binary search tree search operation. We use the following
steps to search an element in AVL tree...

 Step 1: Read the search element from the user

 Step 2: Compare, the search element with the value of root node in the tree.
 Step 3: If both are matching, then display "Given node found!!!" and terminate the
function
  Step 4: If both are not matching, then check whether search element is smaller or
larger than that node value.
 Step 5: If search element is smaller, then continue the search process in left subtree.
 Step 6: If search element is larger, then continue the search process in right subtree.
 Step 7: Repeat the same until we found exact element or we completed with a leaf
node
 Step 8: If we reach to the node with search value, then display "Element is found" and
terminate the function.
 Step 9: If we reach to a leaf node and it is also not matching, then display "Element not
found" and terminate the function.

Insertion Operation in AVL Tree

In an AVL tree, the insertion operation is performed with O(log n) time complexity. In AVL
Tree, new node is always inserted as a leaf node. The insertion operation is performed as
follows...

 Step 1: Insert the new element into the tree using Binary Search Tree insertion logic.
 Step 2: After insertion, check the Balance Factor of every node.
 Step 3: If the Balance Factor of every node is 0 or 1 or -1 then go for next operation.
 Step 4: If the Balance Factor of any node is other than 0 or 1 or -1 then tree is said to be
imbalanced. Then perform the suitable Rotation to make it balanced. And go for next
operation.

Example: Construct an AVL Tree by inserting numbers from 1 to 8.

Deletion Operation in AVL Tree

In an AVL Tree, the deletion operation is similar to deletion operation in BST. But after every
deletion operation we need to check with the Balance Factor condition. If the tree is balanced
after deletion then go for next operation otherwise perform the suitable rotation to make the
tree Balanced.
Heap is a special case of balanced binary tree data structure where the root-node key is compared with its children
and arranged accordingly. If α has child node β then −
key(α) ≥ key(β)
As the value of parent is greater than that of child, this property generates Max Heap. Based on this criteria, a
heap can be of two types −
For Input → 35 33 42 10 14 19 27 44 26 31
Min-Heap − Where the value of the root node is less than or equal to either of its children.

Max-Heap − Where the value of the root node is greater than or equal to either of its children.

Both trees are constructed using the same input and order of arrival.

Max Heap Construction Algorithm

We shall use the same example to demonstrate how a Max Heap is created. The procedure to create Min Heap is
similar but we go for min values instead of max values.
We are going to derive an algorithm for max heap by inserting one element at a time. At any point of time, heap
must maintain its property. While insertion, we also assume that we are inserting a node in an already heapified
tree.
Step 1 − Create a new node at the end of heap.
Step 2 − Assign new value to the node.
Step 3 − Compare the value of this child node with its parent.
Step 4 − If value of parent is less than child, then swap them.
Step 5 − Repeat step 3 & 4 until Heap property holds.
Note − In Min Heap construction algorithm, we expect the value of the parent node to be less than that of the child
node.
Let's understand Max Heap construction by an animated illustration. We consider the same input sample that we
used earlier.

Max Heap Deletion Algorithm

Let us derive an algorithm to delete from max heap. Deletion in Max (or Min) Heap always happens at the root to
remove the Maximum (or minimum) value.
Step 1 − Remove root node.
Step 2 − Move the last element of last level to root.
Step 3 − Compare the value of this child node with its parent.
Step 4 − If value of parent is less than child, then swap them.
Step 5 − Repeat step 3 & 4 until Heap property holds.