Professional Documents
Culture Documents
DSA - Trees
DSA - Trees
Strictly for internal circulation (within KIIT) and reference only. Not for outside circulation without permission
There are many basic data structures that can be used to solve application problems. Array is a good data
structure that can be accessed randomly and is fairly easy to implement. Linked Lists on the other hand is
dynamic and is ideal for application that requires frequent operations such as add, delete, and update. One
drawback of linked list is that data access is sequential. Then there are other specialized data structures like,
stacks and queues that allows to solve complicated problems using these restricted data structures.
One of the disadvantages of using an array or linked list to store data is the time necessary to search for an
item. Since both the arrays and Linked Lists are linear structures the time required to search a “linear” list is
proportional to the size of the data set. For example, if the size of the data set is n, then the number of
comparisons needed to find (or not find) an item may be as bad as n. So imagine doing the search on a linked
list (or array) with n = 106 nodes. Even on a machine that can do million comparisons per second, searching
for m items will take roughly m seconds. This not acceptable in today’s world where speed at which we
complete operations is extremely important. Time is money. Therefore it seems that better (more efficient)
data structures are needed to store and search data.
In this chapter, we can extend the concept of linked data structure (linked list, stack, queue) to a structure that
may have multiple relations among its nodes. Such a structure is called a tree. A tree is a nonlinear data
structure, compared to arrays, linked lists, stacks and queues which are linear data structures.
Become Rich
leaves
branches
root
root
leaves
branches
nodes
A tree is a finite
nonempty set of nodes
and edges without
having any cycle.
It is an abstract model
of a hierarchical
structure.
Nodes represents the
parent-child relation.
A Sr # Property Value
1 Number of nodes of the tree
2 Height of the tree
B C 3 Root Node of the tree
4 Leaves of the tree
5 Interior nodes of the tree
D E F 6 Ancestors of H node
7 Descendants of B node
8 Siblings of E node
9 Right subtree of A node
G 10 Degree of the tree
11 Parent node of D
12 Child nodes of G
H I 13 Level of node G
Data
Tree is a fundamentally hierarchical structure. Thus, a tree is appropriate to model any reality that
exhibits hierarchy:
File system directories.
Genealogical trees of all sorts: family relationships among individuals, tribes, languages etc.
Classifications systems:
Taxonomic classification of plants and animals.
Dewey decimal (or Library of Congress) classification of books.
Breakdown of a manufactured product into subassemblies, each of turn consists of sub-
subassemblies etc. down to the smallest components.
Structure of a program - main routine is the root, procedures it contains are subtrees, each of
which contains nested procedure definitions etc.
Information storage and retrieval situations such as symbol tables, even though hierarchy may
not be involved.
Expression Tress – Compilers and Interpreters as well in symbolic mathematics program to
represent arithmetic expressions.
Game Tree – Game playing
A binary tree T is defined as a finite set of elements called node such that :
So - a binary tree is a tree data structure in which each node has at most two children
(i.e. either 0 or 1 or 2), which are referred to as the left child and the right child.
If T contains a root R, then the two trees T1 and T2 are called the left and right subtree
of R. If T1 is non empty then its root is called the left successor of R. Similarly if T2 is
not empty then its root is called the right successor of R.
T1 T2
((3+4)*(1-2))
3 + ((5+9)*2)
Full but not Complete Complete but not Full Full and Complete Neither Full nor Complete
The tree is said to be strictly or extended or 2-trees binary tree, if every non-
leaf nodes made in a binary tree has non-empty left and right sub trees. A
strictly binary tree with n leaves always contains 2*n–1 nodes.
Let T be the binary tree. There are 2 ways of representing binary tree in memory.
The first and usual way is called the link representation of T and the second
way which uses a single array called the sequential representation of T.
Sequential Representation
Binary Trees can be represented using 1-D array in memory. The rule to store
binary tree in array are :
tree
If any subtree is empty, then the corresponding pointer will contain NULL values;
if the tree T itself is empty, then ROOT will contain NULL
Approach 2 - Nodes
Binary trees can be represented by links where each node contains the address of
the left child and the right child. If any node has its left or right child empty then
it will have in its respective link field, a null value. A leaf node has null value in
both of its links.
The structure defining a node of binary tree in C is as follows.
struct node
{
struct node *leftChild ; /* points to the left child */
int data; /* data field */
struct node *rightChild; /* points to the right child */
}
Node Structure
Illustration
A tree node should look like the below structure. It has data part and references to its left and right
child nodes.
struct node
{
struct node *leftChild;
int data;
struct node *rightChild;
} *root;
Basic operations that can be performed on binary search tree data structure, are −
Insert − insert a node in a tree / create a tree.
Search − search an element in a tree.
Delete – Delete the tree or delete a node in the tree.
Preorder Traversal − traverse a tree in a preorder manner.
Inorder Traversal − traverse a tree in an inorder manner.
Postorder Traversal − traverse a tree in a postorder manner.
Traversal is a process to visit all the nodes of a tree and may print their values
too. Because, all nodes are connected via edges, traverse always start from the
root node and one cannot random access a node in tree. There are three ways to
traverse a tree −
In-order Traversal
Pre-order Traversal
Post-order Traversal
In this traversal method, the left-subtree is visited first, then root and then the
right sub-tree.
Recursive Algorithm
Step 1 − Start
Step 2 − Repeat steps 3, 4 and 5 until all nodes
are traversed
Step 3 − Recursively traverse left subtree
Step 4 − Visit root node
Step 5 − Recursively traverse right subtree
Step 6 − Stop
Output
Traversal start from A, and following in-order traversal, we move to its left subtree B. B is also traversed in-
ordered and the process goes on until all the nodes are visited. The output of in-order traversal of this tree is
D→B→E→A→F→C→G
School of Computer Engineering
Pre-order Traversal
29
In this traversal method, the root node is visited first, then left subtree and finally
right sub-tree.
Recursive Algorithm
Step 1 − Start
Step 2 − Repeat steps 3, 4 and 5 until all nodes
are traversed
Step 3 − Visit root node
Step 4 − Recursively traverse left subtree
Step 5 − Recursively traverse right subtree
Step 6 − Stop
Output
Traversal 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-ordered. And the process goes on until all the nodes are visited. The output of pre-order
traversal of this tree is A → B → D → E → C → F → G
School of Computer Engineering
Post-order Traversal
30
In this traversal method, the root node is visited last, hence the name. First the
left subtree is traversed, then right subtree and finally root.
Recursive Algorithm
Step 1 − Start
Step 2 − Repeat steps 3, 4 and 5 until all nodes
are traversed
Step 3 − Recursively traverse left subtree
Step 4 − Recursively traverse right subtree
Step 5 − Visit root node
Step 6 − Stop
Output
Traversal start from A, and following pre-order traversal, we first visit left subtree B. B is also traversed post-
ordered. And the process goes on until all the nodes are visited. The output of post-order traversal of this tree is D
→E→B→F→G→C→A
School of Computer Engineering
Binary Tree C Implementation
31
In this traversal method, visit the nodes level by level from left to right
Recursive Algorithm
Step 1 − Start
Step 2 − Visit the root node (Level 0)
Step 3 − Visit the root’s left child followed by
right child (Level 1)
Step 4 − Recursively visit the next levels from left
most child to right most child (Level 2 and
onwards) until all levels are covered
Step 5 − Stop
Output 10 → 12 → 23 → 14 → 15 → 16 → 27 → 28
In Order : B → D → A → G → E → C → H → F → I In Order : a → b → c → d → e → f → g → h → i → j → k
Pre Order : A → B → D → C → E → G → F → H → I Pre Order : f → b → a → d → c → e → i → h → g → k → j
Post Order : D → B → G → E → H → I → F → C → A
Post Order : a → c → e → d → b → g → h → j → k → i → f
Note
In Order : LPR Pre Order : PLR Post Order : LRP
1. Create a stack.
2. Push the root into the stack and set the root = root.left and continue till it hits NULL.
3. if root is null and stack is empty then
return // we are done.
else
pop the top node from the stack and set it as, root = popped_node
print the root and go right, root = root.right
Go to step 2.
4. end if
Animation
http://algorithms.tutorialhorizon.com/files/2015/12/Inorder1.gif
Class Work
Design non-recursive algorithm for Pre-order Traversal
Design non-recursive algorithm for Post-order Traversal
In Order : B → D → A → G → E → C → H → F → I
36
In Order : B → D → A → G → E → C → H → F → I
Pre Order : A → B → D → C → E → G → F → H → I
Steps to be followed
37
38
In Order : B → D → A → G → E → C → H → F → I
Post Order : D → B → G → E → H → I → F → C → A
Steps to be followed
39
40
Pre Order : A → B
Post Order : B → A
Conclusion
One cannot create an exact binary tree from preorder and postorder only as you
would never be able to estimate the left/right child of the tree.
You need the inorder traversal along with the any of the above
A threaded binary tree is a binary tree in which the nodes that don’t have a
right child, have a thread to their inorder successor. The idea of threaded
binary trees is to make inorder traversal faster and do it without stack and
without recursion.
Types of threaded binary trees:
Single Threaded: each node is threaded towards either the in-order
predecessor or successor (left or right) means all right null pointers will point
to inorder successor OR all left null pointers will point to inorder predecessor.
Double threaded: each node is threaded towards both the in-order
predecessor and successor (left and right) means all right null pointers will
point to inorder successor AND all left null pointers will point to inorder
predecessor.
A binary search tree (BST) is a tree in which all nodes follows the below mentioned
properties −
The left sub-tree of a node has data less than to its parent node's data.
The right sub-tree of a node has data greater than to its parent node's data.
Thus, a BST divides all its sub-trees into two segments; left sub-tree and right sub-tree and
can be defined as - left_subtree (data) < node (data) < right_subtree (data)
Example Quick Questions?
Question - Where is the smallest & largest element in
binary search tree resides?
Answer - Leftmost & Rightmost Positions
if tree is empty
create a root node with the new key
else
compare key with the top node
if key = node key
replace the node with the new value
else if key > node key
compare key with the right subtree:
if subtree is empty create a leaf node
else add key in right subtree
else key < node key
compare key with the left subtree:
if the subtree is empty create a leaf node
else add key to the left subtree
else if the key value in the node is greater than the target
return the result of searching the left subtree
else if the key value in the node is smaller than the target
return the result of searching the right subtree
School of Computer Engineering
BST– Search - C Function
48
/* return a pointer to the node that contains key. If there is no such node, return NULL */
node* search(node * root, int key)
{
if (!root)
{
return NULL;
}
if (key == root->key)
{
return root;
}
while (root -> left != NULL) while (root -> right != NULL)
{ {
root = root -> left; root = root -> right;
} }
Removing a node from a BST is a bit more complex, since any “holes” should not be created in the
tree. The intention is to remove the specified item from the BST and adjusts the tree.
The binary search algorithm is used to locate the target item: starting at the root, it probes down
the tree till it finds the target or reaches a leaf node.
Experimenting the cases
if the tree is empty return false
else attempt to locate the node containing the target using the binary search
algorithm:
if the target is not found return false
else the target is found, then remove its node & return true. Now while
removing the node four cases may happen
Case 1 - if the node has 2 empty subtrees
Case 2 - if the node has a left and a right subtree
Case 3 - if the node has no left child
Case 4 - if the node has no right child
Z
5 9 5 9
4 6 8 10 6 8 10
4 6 8 10 4 8 10
5 9 6 9
6 8 10 8 10
5 9 9
4
4 8 10 8 10
If at any given node, absolute difference of height of left sub-tree and height of right
sub-tree (called as balance factor) is not greater than 1 (i.e. should be -1 or 1 or 0)
Balanced Unbalanced
What if the input to binary search tree comes in sorted (ascending or descending) manner? It will then look like
this −
It is observed that BST's worst-case performance closes to linear search algorithms, that is Ο(n). In real time data
we cannot predict data pattern and their frequencies. So a need arises to balance out existing BST. Named after
their inventor Adelson, Velski & Landis, AVL trees are height balancing binary search tree. AVL tree checks the
height of left and right sub-trees and assures that the difference is not more than 1. This difference is called
Balance Factor. Balance Factor = height(left-subtree) − height(right-subtree)
If the difference in the height of left and right sub-trees is more than 1, the
tree is balanced using rotation techniques.
To make itself balanced, an AVL tree may perform four kinds of rotations −
Left rotation
Right rotation
Left-Right rotation
Right-Left rotation
First two rotations are single rotations and next two rotations are double
rotations.
If a tree become unbalanced, when a node is inserted into the right subtree
of right subtree, then we perform single left rotation −
-
AVL tree may become unbalanced if a node is inserted in the left subtree of
left subtree. The tree then needs a right rotation.
As depicted, the unbalanced node becomes right child of its left child by
performing a right rotation.
State Action
State Action
- Node A is still unbalanced because of right subtree
- of its right subtree and requires a left rotation.
Insertion Deletion
Imbalance at 5
Perform Rotation with 8
https://www.cs.usfca.edu/~galles/visualization/AVLtree.html
Searching for a key in an m-way search tree is similar to that of binary search tree
52
52
K : Key K
Ai , Aj : Pointers to sub-tree Ai Aj
Deletion Cases
[1] If (Ai = Aj = NULL) then delete K
[2] If (Ai NULL, Aj = NULL ) then choose the largest of the key elements K’ in
the child node pointed to by Ai and replace K by K’.
[3] If (Ai = NULL, Aj NULL ) then choose the smallest of the key element K”
from the subtree pointed to by Aj , delete K” and replace K by K”.
[4] If (Ai NULL, Aj NULL ) then choose the largest of the key elements K’ in
the subtree pointed to by Ai or the smallest of the key element K” from the
subtree pointed to by Aj to replace K.
Ai = Aj = NULL
Delete 151 18 44 76 198
X X
80 92 141 262
7 12
X X X
X X
Action : delete K X X X X
Ai = Aj = NULL
18 44 76 198
Post to the
X X Deletion of 151
80 92 141 262
7 12
X X X
X X
Ai NULL, Aj = NULL
Delete 12 18 44 76 198
X X
80 92 141 262
7 12
X X X
X X
Action : choose the smallest of the key element K” 272 286 350
from the subtree pointed to by Aj , delete K” and X X X X
replace K by K”
School of Computer Engineering
Deletion Case – 2 Result
81
80 92 141 262
7 10
X X X
X X
Ai = NULL, Aj NULL
Delete 262 18 44 76 198
X X
80 92 141 262
7 12
X X X
X X
Action : choose the largest of the key elements K’ 272 286 350
in the child node pointed to by Ai and replace K X X X X
by K’.
School of Computer Engineering
Deletion Case – 3 Result
83
80 92 141 272
7 12
X X X
X X
286 350
X X X
Ai NULL, Aj NULL
Delete 198 18 44 76 198
X X
80 92 141 262
7 12
X X X
X X
C D F H I
A forest can be converted to a general tree (or simply tree i.e. number of subtrees
for any node is not required to be 0, 1, or 2) by adding a single node to serve as the
root node of the tree in which each of the original trees are sub-tree. Example –
B E G
C D F H I
School of Computer Engineering
Forest cont…
87
Conversely, deleting the root from a tree leaves behind a forest consisting of its subtrees.
(Obviously, this is how we got our forest from our original tree.)
B E G
C D F H I
Can we provide or say, nodes with 1000 pointer fields in order to be able to represent
general trees where nodes might have up to 1000 children? In any given case, most of
the fields of all the node records will be unused, so a great deal of memory is required -
and wasted. And what if we want to introduce a node with 1001 children? We have to
reconfigure the implementation to accommodate this one "anomalous" node. Surely,
this is not satisfactory. Remarkably, a forest can be represented by a binary tree. Note
that the resulting tree is a binary tree but not a binary search tree. Obviously, an
empty forest can be represented by the empty binary tree.
Example Step 1: Root Node of General tree becomes the Root node
of binary tree.
Step 2: Now Root Node (A) has three child Nodes (B, H, E)
in general tree. The leftmost node (B) of the root node (A)
in the general tree becomes the left most node of the root
node (A) in binary tree.
Step 3: Now Node H becomes the right node of B and Node E becomes the right node of
H.
Step 4: Now Node B has only one left child node, which is C in general tree. So Node C
becomes left child of Node B in binary tree.
Step 5: Now Node E has two child nodes (F, G). The leftmost node (F) of the node (E) in
the general tree becomes the left most node of the node E in the binary tree.
M-way binary search trees have the advantage of having a node storing multiple values.
However it is essential that the height of the tree be kept as low as possible and
therefore their arises the need to maintain balanced m-way search trees. Such a balanced
m-way search tree is called B-tree.
The root has at least two child nodes and at most m child nodes
Internal nodes except the root have at least m/2 child nodes and at most m child
nodes
The number of keys in each internal node is one less than the number of child nodes
and these keys partition the keys in the subtrees of nodes in a manner similar to that
of m-way search trees
All leaf nodes are on the same level
48
56 64 85
31 45
46 47
X X X 87 88 100 112
10 18 21
X X X X X
X X X X
58 62
X X X 49 51 52
36 40 42 X X X X
X X X X 67 75
X X X
Searching for a key in a B-tree is similar to the one on an m-way search key. The number
of accesses depends on the height h of the B-Tree.
Class Work
Draw the path to search for the key:
9
20
53
21
1. B-tree starts with a single root node (which is also a leaf node) at level 0.
2. Once the root node is full with m – 1 search key values and when attempt is made to
insert another entry in the tree, the root node splits into two nodes at level 1.
3. Only the middle value is kept in the root node, and the rest of the values are split
evenly between the other two nodes. i.e. the first (m-1)/2 values goes to left, the last
(m-1)/2 values goes to right.
4. When a non-root node is full and a new entry is inserted into it, that node is split into
two nodes at the same level, and the middle entry is moved to the parent node along
with two pointers to the new split nodes.
5. If the parent node is full, it is also split.
6. Splitting can propagate all the way to the root node, creating a new level if the root is
split.
B-Tree where m =5
Insert 17
Insert 6
Add it to the leftmost leaf. That overflows, so we split it: Left = [ 2 3 ], Middle = 5, Right = [ 6 7 ]
Left and Right become nodes; Middle is added to the node above with Left and Right as its children. The node
above (the root in this small example) does not overflow, so we are done.
Insert 21
Add it to the middle leaf. That overflows, so we split it: Left = [ 17 21 ], Middle = 22, Right = [ 44 45 ]
Left and Right become nodes; Middle is added to the node above with Left and Right as its children. The node
above (the root node in this small example) does not overflow, so we are done.
Insert 67
Add it to the rightmost tree. That overflows, so we split it: Left = [ 55 66 ], Middle = 67, Right = [ 68 70 ]
Left and Right become nodes; Middle is added to the node above with Left and Right as its children.
But now the node above does overflow. So it is split in exactly the same manner: so we split it:
Left = [ 5 10 ], Middle = 22, Right = [ 50 67 ]
Left and Right become nodes; , the children of Middle. If this were not the root, Middle would be added to the
node above and the process repeated. If there is no node above, as in this example, a new root is created with
Middle as its only value.
48
56 64 85
31 45
X X X X
X X X
Delete 85
48
56 64
31 45
X X X
X X X
31 45 31 42
46 47 46 47
Delete 45
X X X 10 18 21 X X X
10 18 21
X X X X
X X X X
36 40 42
36 40
X X X X
X X X
46
Delete 46
10 18 21 X X 45
10 18 21
X X X X X X
X X X X
36 40
Rich sibling for the 36 40 42
node with key 46 X X 42 X
X X X X
46
Delete 46
10 18 21 X X
10 18 21 42 45
X X X X
X X X X X X 42 X
In a B+ tree, the internal nodes have no data – only the leaves do!
Each internal node still has up-to M-1 keys
Subtree between two keys x and y contain leaves with values v such that x ≤ v < y
Leaf nodes have up-to L (i.e. data items in leaf) sorted keys
From the root to the leaf all paths should be of same length
Properties:
Root (Special Case)
Has between 2 and M children
Internal Nodes
Store up-to M-1 keys
Have between M/2 and M children
Leaf Nodes Red arrow represents data elements
Green rectangle represents the node with key
Where data is stored and data elements
A binary tree has 9 nodes. The inorder and preorder traversal of T yields the
following sequence of node:
Inorder: E, A, C, K, F, H, D,B,G and Preorder: F, A, E, K, C, D, H, G, B
Draw the tree T
Suppose T is a binary tree. Write a recursive & non-recursive algorithm to
find the number of leaf nodes, number of nodes and depth in T. Depth of T is
1 more than the maximum depths of the depths of the left and right subtrees
of T.
Suppose T is a binary tree. Write a recursive & non-recursive algorithm to
find the height of T.
Insert the following keys in the order to form the binary search tree
J, R, D, G, T, E, M, H, P, A, F, Q
Insert the following keys in the order to form the binary search tree
50, 33, 44, 22, 77, 35, 60, 40
Suppose a binary tree T is in memory. Write the pseudo code to delete all
terminals or leaf nodes in T
School of Computer Engineering
Assignments cont…
111
Find out the inorder, preorder and postorder traversal of the following tree.
Draw a complete binary tree with exactly six nodes. Put a different value in
each node. Then draw an array with six components and show where each of
the six node values would be placed in the array (using the usual array
representation of a complete binary tree).
Draw a binary taxonomy tree that can be used for these four animals: Rabbit,
Horse, Whale, Snake. A binary taxonomy tree is also called as binary decision
tree that allows to going down the tree with simple test.
Yes No
Are you bigger than a cat Do you live underwater?
Yes No Yes No
Kangaroo Mouse Trout Robin
Write a function that traverses a threaded binary tree in postorder. What are
the time and space requirement of your method?
Write a function that traverses a threaded binary tree in preorder. What are
the time and space requirement of your method?
Write pseudo code to delete the node with key k from a binary search tree.
Assume that a binary search tree is represented as a threaded binary search
tree. Write functions to search, insert and delete
Write an algorithm to construct the binary tree with given preorder and
inorder.
Write the pseudo code to construct the binary tree with given postorder and
inorder.
Prove that every binary tree is uniquely by its preorder and inorder
sequences.
Please provide constructive suggestions to this course in terms of lectures,
home works, or any other aspects
http://www.geeksforgeeks.org/binary-tree-data-structure/
http://www.geeksforgeeks.org/binary-search-tree-data-structure/
https://www.tutorialspoint.com/data_structures_algorithms/tree_data_structure.htm
http://btechsmartclass.com/DS/U3_T1.html
http://btechsmartclass.com/DS/U3_T3.html
https://www.hackerrank.com/domains/data-structures/trees
https://www.youtube.com/watch?v=qH6yxkw0u78
http://nptel.ac.in/courses/106102064/6
What is a B tree?
A B-tree of order m (the maximum number of children for each node) is a tree which
satisfies the following properties :