MELJUN CORTES Jedi slides data st-chapter05-trees

1Data Structures – Trees

5 Trees

2Data Structures – Trees

ObjectivesAt the end of the lesson, the student should be able to:● Discuss the basic concepts and definitions on trees● Identify the types of trees: ordered, oriented and free tree● Use the link presentation of trees● Explain the basic concepts and definitions on forests

<next page>

3Data Structures – Trees

Objectives

● Convert a forest into its binary tree representation and vice versa using natural correspondence

● Traverse forests using preorder, postorder, level-order and family-order

● Create representation of trees using sequential allocation● Represent trees using arithmetic tree representations● Use trees in an application: the equivalence problem

4Data Structures – Trees

Definition and Related Concepts

– *degree of a tree - degree of node(s) of highest degree● Ordered Tree - order of each node is significant

● Oriented Tree – order of the subtrees of every node is irrelevant

5Data Structures – Trees

Definition and Related Concepts

● Free Tree – tree w/o a root and significant node orientation

● Progression of Trees

6Data Structures – Trees

Link Representation of Trees● Node structure of a tree node:

● Some properties of a tree with n nodes and degree k:– The number of link fields = n * k– The number of non-null links = n-1(#branches)– The number of null links = n*k - (n-1) = n (k-1) + 1

● Alternative structure for better space utilization:

7Data Structures – Trees

Forests● zero or more disjoint trees taken together● ordered forest - if trees comprising a forest are ordered

trees and if their order in the forest is material● Natural Correspondence – method used to convert an

ordered forest into a unique binary tree and vice versa

Let F = (T1, T2, ..., Tn) be an ordered forest of ordered trees. The binary tree B(F) corresponding to F is obtained as follows:

● If n = 0, then B(F) is empty.● If n > 0, then the root of B(F) is the root of T1; the left subtree

of B(F) is B( T11, T12, ... T1m ) where T11, T12, ... T1m are the subtrees of the root of T1; and the right subtree of B (F) is B( T2, T3, ..., Tn ).

●

8Data Structures – Trees

Forests– Non-recursive approach implementation:

1) Link together the sons in each family from left to right. (Note: the roots of the tree in the forest are brothers, sons of an unknown father.)

2) Remove links from a father to all his sons except the oldest (or leftmost) son.

3) Tilt the resulting figure by 45 degrees.

9Data Structures – Trees

Forests●

10Data Structures – Trees

Forests● Forest Traversal

– forests can only be traversed in preorder and postorder since the middle node concept is not defined

● Preorder Traversal1) Visit the root of the first tree.2) Traverse the subtrees of the first tree in preorder.3) Traverse the remaining trees in preorder.

● Postorder Traversal1) Traverse the subtrees of the first tree in postorder.2) Visit the root of the first tree.3) Traverse the remaining trees in postorder.

– Note: Forest postorder is the same as the B(F) inorder

11Data Structures – Trees

Forests● Forest Traversal

12Data Structures – Trees

Forests● Sequential representation of forests

● preorder sequential representation– Using RLINK

actual internal representation:

13Data Structures – Trees

Forests● Sequential representation of forests

– preorder sequential representation● Using RTAG and a stack

● Actual internal representation:

14Data Structures – Trees

Forests● Sequential representation of forests

– family-order sequential representation● Using LLINK

● Actual internal representation:

15Data Structures – Trees

Forests● Sequential representation of forests

– family-order sequential representation● Using LTAG

● Actual internal representation:

16Data Structures – Trees

Forests● Sequential representation of forests

– level-order sequential representation● Using LTAG and a queue

● Actual internal representation:

17Data Structures – Trees

Forests● Converting from sequential to link representation

BinaryTree convert(){BinaryTree t = new BinaryTree();BTNode alpha = new BTNode();LinkedStack stack = new LinkedStack();BTNode sigma;BTNode beta;

t.root = alpha;for (int i=0; i<n-1; i++){

beta = new BTNode();if (RTAG[i] == 1) stack.push(alpha);else alpha.right = null;if (LTAG[i] == 1){

alpha.left = null;sigma = (BTNode) stack.pop();sigma.right = beta;

} else alpha.left = beta;alpha.info = INFO[i];alpha = beta;

}alpha.info = INFO[n-1];return t;

}

18Data Structures – Trees

Arithmetic Tree Representations

● degree - number of children of a node● weight - number of descendants of a node

19Data Structures – Trees

Arithmetic Tree Representations

● preorder sequence with degrees

● preorder sequence with weights

● postorder sequence with degrees

● postorder sequence with weights

●

INFO 1 2 5 11 6 12 13 7 3 8 4 9 14 15 16 10WEIGHT 15 6 1 0 2 0 0 0 1 0 5 3 2 0 0 0

INFO 11 5 12 13 6 7 2 8 3 15 16 14 9 10 4 1DEGREE 0 1 0 0 2 0 3 0 1 0 0 2 1 0 2 3

INFO 11 5 12 13 6 7 2 8 3 15 16 14 9 10 4 1WEIGHT 0 1 0 0 2 0 6 0 1 0 0 2 3 0 5 15

INFO 1 2 5 11 6 12 13 7 3 8 4 9 14 15 16 10DEGREE 3 3 1 0 2 0 0 0 1 0 2 1 2 0 0 0

20Data Structures – Trees

Arithmetic Tree Representations

● level-order sequence with degrees

● level-order sequence with weights

INFO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16DEGREE 3 3 1 2 1 2 0 0 1 0 0 0 0 2 0 0

INFO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16WEIGHT 15 6 1 5 1 2 0 0 3 0 0 0 0 2 0 0

21Data Structures – Trees

Equivalence Problem● equivalence relation - relation between the elements of a

set of objects S satisfying the following three properties for any objects x, y and z (not necessarily distinct) in S:

(a) Transitivity: if x ≡ y and y ≡ z then x ≡ z (b) Symmetry: if x ≡ y then y ≡ x (c) Reflexivity: x ≡ x

● Equivalence ProblemGiven any pairs of equivalence relations of the form i ≡ j for any i, j in S, determine whether k is equivalent to i, for any k, i in S, on the basis of the given pairs.

● Theorem: An equivalence relation partitions its set S into disjoint classes, called equivalence classes, such that two elements are equivalent if and only if they belong to the same equivalence class

22Data Structures – Trees

Equivalence Problem● Computer implementation

– use trees to represent equivalence classes– use union operation to merge equivalence classes - setting a tree

as a subtree of another tree– use find operation to to determine if two objects belong to the same

equivalence class or not – "do the objects have the same root in the tree?”

23Data Structures – Trees

Equivalence Problem● class Equivalence{

int[] FATHER;int n;Equivalence(){}Equivalence(int size){

n = size+1; /* +1 since FATHER[0] will not be used */

FATHER = new int[n];}

void setSize(int size){FATHER = new int[size+1];

}

24Data Structures – Trees

Equivalence Problem● void setEquivalence(int a[], int b[]){

int j, k;for (int i=0; i<a.length; i++){

j = a[i];k = b[i];while (FATHER[j] > 0) j = FATHER[j];while (FATHER[k] > 0) k = FATHER[k];/* If not equivalent, merge the two trees */if (j != k) FATHER[j] = k;}

}

/* Returns true if equivalent, else returns false */boolean test(int j, int k){

while (FATHER[j] > 0) j = FATHER[j];while (FATHER[k] > 0) k = FATHER[k];/* If they have same root, they are equivalent */if (j == k) return true;else return false;

}

25Data Structures – Trees

Equivalence Problem● Degeneracy and the Weighting Rule for Union

– problem with the previous algorithm: degeneracy - producing a tree that has the deepest possible height (yielding O(n) time complexity)

– Consider the set S = { 1, 2, 3, ..., n } and the equivalence relations 1 ≡ 2, 1 ≡ 3, 1≡ 4, ..., 1 ≡ n:

Best-Case Forest (Tree)Worst-Case Forest (Tree)

26Data Structures – Trees

Equivalence Problem● Degeneracy and the Weighting Rule for Union

– to solve the problem, we use a technique known as the weighting rule for union

Let node i and node j be roots. If the number of nodes in the tree rooted at node i is greater than the number of nodes in the tree rooted at node j, then make node i the father of node j; else, make node j the father of node i

/* Implements weighting rule for union, O(1) time */void union(int i, int j){

int count = FATHER[i] + FATHER[j];if (Math.abs(FATHER[i]) > Math.abs(FATHER[j] {FATHER[j] = i;FATHER[i] = count;

} else{FATHER[i] = j;FATHER[j] = count;

}}

27Data Structures – Trees

Equivalence Problem● Worst-case trees and the Collapsing Rule for Find

28Data Structures – Trees

Equivalence Problem● Worst-case trees and the Collapsing Rule for Find

– let n1, n2, ..., nm be nodes in the path from node n1 to the root r. To collapse, we make r the father of np, 1 ≤ p < m:

29Data Structures – Trees

Equivalence Problem● Worst-case trees and the Collapsing Rule for Find

/* Implements the collapsing rule for find. Returns the root of i */int find(int i){

int j, k, l;k = i;/* Find root */while (FATHER[k] > 0) k = FATHER[k];

/* Compress path from node i to the root */j = i;while (j != k){

l = FATHER[j];FATHER[j] = k;j = l;

}return k;

}

30Data Structures – Trees

Summary● Trees may be ordered, oriented or free● Link allocation can be used to represent trees. Trees can also be

represented sequentially using arithmetic tree representation.● Zero or more disjoint trees taken together are known as a forest● An ordered forest may be converted into a unique binary tree and

vice versa using natural correspondence● Forests can be traversed in preorder and postorder● Forests can be represented sequentially using preorder, family-

order and level-order sequential representations● The equivalence problem can be solved using trees and the union

and find operations. The weighting rule for union and the collapsing rule for find aid in better algorithm performance.