Data Structure and

Algorithm (CS-102)
Ashok K Turuk
 Discussed So far
• Here are some of the data structures
we have studied so far:
– Arrays
– Stacks, Queues and deques
– Linked list

• Inherently uni-dimensional in structure

2
 Tree
A tree is defined as a finite set of one or
more nodes such that
[a] There is a specially designated
node called the root and

[b] The rest of the nodes could be

partitioned into t disjoint sets (t >0)
each set representing a tree Ti, i=1,2, .
. . t known as subtree of the tree.
3
 Tree

A node in the definition of the tree

represents an item of information, and
the links between the nodes termed as
branches, represent an association
between the items of information.

4
 A Level 1

B C D E Level 2

F G H I J K Level 3

L Level 4

5
 Tree

• Definition of Tree emphasizes on the

aspect of

[a] Connectedness, and

[b] Absence of closed loops

6
 Basic terminologies

• degree of the node

• leaf nodes or terminal nodes
• non terminal nodes
• children
• siblings
• ancestors
• degree of a tree
• hierarchical structure
• height or depth of a tree
• forest
7
 Tree Terminology
• A tree consists of a collection of
elements or nodes, with each node
linked to its successors
• The node at the top of a tree is called
its root
• The links from a node to its successors
are called branches
• The successors of a node are called its
children
8
 Tree Terminology (continued)
• Each node in a tree has exactly one
parent except for the root node, which
has no parent
• Nodes that have the same parent are
siblings
• A node that has no children is called a
leaf node
• A generalization of the parent-child
relationship is the ancestor-descendent
relationship
9
Tree Terminology (continued)
• The predecessor of a node is called its
parent

• A subtree of a node is a tree whose

root is a child of that node

• The level of a node is a measure of its

distance from the root
10
Tree Terminology (continued)
• Node: stores the actual data and links
to other nodes
• Parent: immediate predecessor of a
node
• Root: specially designated node which
has no parent
• Child:immediate successor of a node.

11
 Tree Terminology(continued)

• Leaf: node without any child

• Level: rank of the hierarchy and root

node has level zero(0). Node at level i
has the level i+1 for its child and i-1 for
its parent. This is true for all nodes
except the root
12
Tree Terminology (continued)
• Height (depth): Maximum number of
nodes possible in a path starting from
root node to leaf node. Height of a tree
given by h = lmax, lmax is the maximum
level of the tree.
• Degree of node maximum number of
children possible for a node
• Siblings  nodes having the same
parent

13
 Tree Terminology
• Ancestor of a Node: Those nodes that
occur on the path from the root to the
given node

• Degree of a Tree: Maximum degree of

the node in the tree

• Forest : A set of Zero or more Disjoint

trees.
14
Degree of the tree =
A Level 1
4 ( Max degree of A)

B C D E Level 2

F G H I J K Level 3

Height of the tree = 4

L Level 4
(Max level)

15
 Representation of a tree

• List Representation

(A (B(F,G,H), C, D(I), E(J,K(L))) ) for the tree

Considered in the Example

• Linked List Representation

16
 LINK 1 LINK 2 LINK n
…
DATA

(a) General node structure

T

B C D E

F G H I J K

L
(b) Linked list representation of the tree 17
An alternative elegant linked representation

TAG DATA / DOWNLINK LINK

1/0

(a) General node structure

18
An alternative elegant linked representation

1 A 0 1 C 0 0

1 B 1 F 1 G 1 H

1 D 1 I

1 E 1 J O

1 K 1 L

(b) Linked representation of the tree

19
 Binary Trees
A binary tree T is defined as a finite set
of elements called nodes such that

[a] T is empty (Called the Null tree or

Empty tree) or
[b] T contains a distinguished node R
called the root of T and the remaining
nodes of T form an ordered pair of
disjoint binary trees T1 and T2
20
 Binary Trees

• A binary tree has the characteristic of all

nodes having at most two branches, that is,
all nodes have a degree of at most 2.

• A binary tree can therefore be empty or

consist of a root node and two disjoint
binary trees termed left subtree and
right subtree.
21
 A Level 1

B C Level 2

D E F G Level 3

22
Important observations regarding binary
trees:

 The maximum number of nodes on level i of

a binary tree is 2i-1, i>1

 The maximum number of nodes in a binary

tree of height h is 2h-1, h>1

 For any non empty binary tree, if to is the

number of terminal nodes and t2 is the
number of nodes of degree 2, then to=t2+1
23
A binary tree of height h which has all its
permissible maximum number of nodes
viz., 2h-1 intact is known as a full binary
tree of height h.

1 A

2 B
3
C

D E 6 F
4 5 7 G
24
A binary tree with n’ nodes and height h is
complete if its nodes correspond to the nodes
which are numbered 1 to n (n’ n) in a full
binary tree of height h.
Height of a complete
1 A binary tree with n
given by

2 B C 3 h  log 2 (n  1)

4 D
5 E 6 F

25
A complete binary tree obeys the following
properties with regard to its node
numbering:

[a] If a parent node has a number i then its

left child has the number 2i (2i < n). If 2i > n
then i has no left child.

[b] If a parent node has a number i, then its

right child has the number 2i+1 (2i + 1 <n). If
2i + 1 > n then i has no right child.

26
A complete binary tree obeys the following
properties with regard to its node
numbering:

[c] If a child node (left or right) has a number

i then the parent node has the number i /2
if i 1. If i =1 then i is the root and hence
has no parent.

27
A binary tree which is dominated solely by left
child nodes or right child nodes is called a
skewed binary tree or more specifically left
skewed binary tree or right skewed binary
tree respectively.

a m

b n

c o

Left skewed Right skewed p

d
28
Extended Binary Tree: 2-Tree
A binary tree T is said to be 2-Tree or an
extended binary tree if each node N
has either 0 or 2 children.

Nodes with 2 children are called internal

nodes and the nodes with 0 children are
called external nodes.

29
Representation of Binary Tree

Binary tree can be represented by means

of
[a] Array
[b] linked list

30
 Representation Of Binary Trees

Array Representation

1
a
Sequential representation
2
of a tree with depth d will
b require an array with
4 5 approx 2d + 1 elements
c d
10
e f
11

1 2 3 4 5 6 7 8 9 10 11
a b c d e f
31
 Linked representation

T
LCHILD DATA RCHILD

b
c d

e f

32
• Observation regarding the linked
representation of Binary Tree

[a] If a binary tree has n nodes then the

number of pointers used in its linked
representation is 2 * n
[b] The number of null pointers used in
the linked representation of a binary
tree with n nodes is n + 1
33
 Traversing Binary Tree
Three ways of traversing the binary tree
T with root R
Preorder
[a] Process the root R
[b] Traverse the left sub-tree of R in
preorder
[c] Traverse the right sub-tree of R in
preorder
a. k. a node-left-right traversal (NLR)
34
 Traversing Binary Tree
In-order

[a] Traverse the left sub-tree of R in in-

order
[b] Process the root R
[c] Traverse the right sub-tree of R in in-
order

a. k. a left-node-right traversal (LNR)

35
 Traversing Binary Tree
Post-order

[a] Traverse the left sub-tree of R in

post-order
[b] Traverse the right sub-tree of R in
post-order
[c] Process the root R

a. k. a left-right-node traversal (LRN)

36
Illustrations for Traversals
• Assume: visiting a node 1
is printing its label 3 7
• Preorder: 5 8 9
1 3 5 4 6 7 8 9 10 11 12 10
• Inorder:
4 6

4 5 6 3 1 8 7 9 11 10 12 11 12
• Postorder:
4 6 5 3 8 11 12 10 9 7 1

37
 Illustrations for Traversals (Contd.)

• Assume: visiting a node 15

is printing its data 8 20
• Preorder: 15 8 2 6 3 7
11 10 12 14 20 27 22 30 2 11 27

• Inorder: 2 3 6 7 8 10 11 30
6 10 12 22
12 14 15 20 22 27 30
• Postorder: 3 7 6 2 10 14 3 7 14

12 11 8 22 30 27 20 15

38
 Formulation of Binary tree from
Its traversal
1. If preorder is given=>First node is the
root
If postorder is given=>Last node is the
root

2. Once the root node is identified ,all nodes

in the left subtrees and right subtrees of
the root node can be identified.

3. Same technique can be applied repeatedly

to form subtrees

39
4.Two traversals are essential out of
which one should inorder, another may
be preorder or postorder

5. But we can’t form a binary tree if only

preorder and postorder has given.

40
 Example: For Given Inorder and
Preorder
Inorder: D B H E A I F J CG
Preorder: A B D E H C F I J G

Now root is A
Left subtree: D B H E
Right subtree: I F J C G

41
 continues.
A

In:D B H E IFJCG
Pre:B D E H CFIJG

D HE IFJ G
EH FIJ

I J
H

42
 Example: For Given Inorder and
Postorder

Inorder: n1,n2, n3, n4, n5, n6, n7,

n8, n9
Postorder: n1,n3, n5, n4, n2, n8,
n7, n9, n6

So here n6 is the root

43
 n6

In:n1,n2,n3,n4,n5 n7,n8,n9
Post:n1,n3,n5,n4,n2 n8,n7,n9

n1 n3,n4,n5 n7,n8

n3,n5,n4 n8,n7

n3 n5 n8
44
Traversal Algorithm Using Stack
Assumption

Binary Tree is represented by

TREE(INFO, LEFT, RIGHT, ROOT)

A variable PTR (pointer) will contain the
location of the node N currently being
scanned. An array STACK will hold
the addresses of the node for future
processing
45
 Pre-Order Traversal
[1] [ Initially push NULL onto STACK and
initialize PTR]
Set TOP =1, STACK[1] = NULL and PTR
= ROOT
[2] Repeat Steps 3 to 5 while PTR 
NULL
[3] Apply PROCESS to PTR->INFO

46
 Pre-Order Traversal
[4] [Right Child ?]
If PTR -> RIGHT  NULL, then [Push
on STACK]
SET TOP = TOP + 1
STACK[TOP] = PTR->RIGHT
[5] [Left Child ?]
If PTR->LEFT  NULL, Then
Set PTR = PTR->LEFT
Else
Set PTR = STACK[TOP],
TOP = TOP-1
[6] Exit
47
 Pre-Order Traversal
A
B C
D E F
G H
K

48
[1] Initially push NULL onto STACK
STACK = φ
Set PTR = A , the root of T
[2] Proceed down the left-most path rooted at
PTR = A as follows
(i) Process A and Push its right child C onto
STACK:
STACK: φ, C
(ii) Process B. (There is no Right Child)
(iii) Process D and push its Right Child H
onto STACK. STACK: φ, C, H
(iv) Process G (There is no right child)
49
[3][Backtracking] Pop the top element H from
STACK, and set PTR = H
STACK: φ, C

[4] Proceed down the left-most path rooted at PTR =

H as follows
(v) Process H and Push its right child K onto
STACK:
STACK: φ, C, K
[No other node is processed, since H has no left
child]

[5] [Backtracking] Pop the top element K from

STACK, and set PTR = K
STACK: φ, C
50
[6] Proceed down the left-most path rooted at PTR = K
as follows
(vi) Process K. (There is no right child)
[No other node is processed, since K has no left child]
[7] [Backtracking] Pop the top element C from STACK,
and set PTR = C
STACK: φ
[8] Proceed down the left-most path rooted at PTR = C
as follows
(vii) Process C and push its right child F onto STACK.
STACK: φ, F
(viii) Process E (There is no right child)

51
[9] [Backtracking] Pop the top element F
from STACK, and set PTR = F
STACK: φ
[10] Proceed down the left-most path
rooted at PTR = F as follows
(ix) Process F. (There is no right child)
[No other node is processed, since F has
no left child]
[11] [Backtracking] Pop the top element
NULL from STACK, and set PTR = NULL

52
 In-order Traversal
[1] [Push NULL onto STACK and initialize
PTR]
Set TOP =1, STACK[1] = NULL, PTR =
ROOT
[2] Repeat while PTR  NULL [Pushes the
Left-most path onto STACK]
(a) Set TOP = TOP + 1, STACK[TOP] = PTR
(b) Set PTR = PTR -> LEFT
[3] Set PTR = STACK[TOP], TOP = TOP -1
[Pops node from STACK]

53
 In-order Traversal
[4] Repeat Steps 5 to 7 while PTR 
NULL: [Backtracking]
[5] Apply PROCESS to PTR->INFO
[6] [Right Child ?] If PTR->RIGHT  NULL
then
(a) Set PTR = PTR->RIGHT
(b) Go to Step 2
[7] Set PTR = STACK[TOP], TOP = TOP -1
[8] Exit
54
 In-Order Traversal
A
B C
D E
G H
K L M

55
[1] Initially Push NULL onto STACK
STACK = φ
Set PTR = A , the root of T
[2] Proceed down the left-most path rooted at
PTR = A, pushing the nodes A, B, D, G and K
onto STACK:
STACK = φ, A, B, D, G, K
[3] [Backtracking] The nodes K, G and D are
popped and processed
STACK = φ, A, B
Set PTR = H [Right Child of D]
[4] Proceed down the left-most path rooted at
PTR = H, pushing the nodes H and L onto
STACK:
STACK = φ, A, B, H, L

56
[5] [Backtracking] Nodes L and H are
popped and processed
STACK = φ, A, B
Set PTR = M, the Right child of H
[6] Proceed down the left-most path rooted
at PTR = M, pushing node M onto STACK
STACK = φ, A, B, M
[7] [Backtracking] Nodes M, B and A are
popped and processed
STACK = φ
Set PTR = C, the Right child of A
57
[8] Proceed down the left-most path
rooted at PTR = C, pushing node C and E
onto STACK
STACK = φ, C, E
[9] [Backtracking] Nodes E and C are
popped and processed.

58