Trees. Dr. Ronaldo Menezes Hugo Serrano Ronaldo Menezes, Florida Tech

Transcription

1 Trees Dr. Ronaldo Menezes Hugo Serrano

2 Introduction to Trees Trees are very common in computer science They come in different variations They are used as data representation in many applications They appear frequently in several algorithmic solution

3 Trees Set of nodes (vertices) and edges (arcs) that connect the nodes together Nodes

4 Trees Set of nodes (vertices) and edges (arcs) that connect the nodes together Edges

5 Trees Set of nodes (vertices) and edges (arcs) that connect the nodes together A path is connected sequence of edges Path

6 Trees Set of nodes (vertices) and edges (arcs) that connect the nodes together A path is connected sequence of edges There is exactly one path between any two nodes in a tree. There is no cycles in trees Path

7 Trees Trees may have one distinguished node called the root These trees are called rooted trees. A tree with no root is called free tree. Rooted Tree

8 Trees The convention is draw the root on the top. In a rooted tree, any node is the root of a subtree. root of subtree Root A subtree

9 Relationships between nodes

10 Relationships between nodes Inspiration from family trees to determine relationships between nodes: Parent Node Children Siblings Ancestor Grandparents

11 Relationships between nodes Relationships Inspiration from family trees to name relationships between nodes: Parent Node Children Siblings Ancestors Parent node Every node except the root has one parent. The parent is the first node on path from a node to the root. Root has no parent If the node p is the c s parent, node c is p s child

12 Relationships between nodes Relationships Inspiration from family trees to name relationships between nodes: Parent Node Children Siblings Ancestors Leaf node A node can have any number of children Nodes with no children are called leaf nodes

13 Relationships between nodes Relationships Inspiration from family trees to name relationships between nodes: Parent Node Children Siblings Ancestors Siblings Nodes that have the same parent.

14 Relationships between nodes Relationships Inspiration from family trees to name relationships between nodes: Parent Node Children Siblings Ancestors Ancestors Nodes on the path from the node to the root including the root. A node is an ancestor of itself. If a node a is an ancestor of a node b, than b is a descendant of a.

15 Structural Properties Property Length of a path Depth of a node Height of a node Height of the tree Subtree rooted at a node Length of a Path Number of edges in a path

16 Structural Properties Property Length of a path Depth of a node Height of a node Height of the tree Subtree rooted at a node Depth of a node Length of the path from the node to the root

17 Structural Properties Property Length of a path Depth of a node Height of a node Height of the tree Subtree rooted at a node Height of a node Length of the path from the node to its deepest descendant.

18 Structural Properties Property Length of a path Depth of a node Height of a node Height of the tree Subtree rooted at a node Height of the tree Height of the root

19 Structural Properties Property Length of a path Depth of a node Height of a node Height of the tree Subtree rooted at a node Subtree rooted at a node Tree formed by the node a and all its descendants

20 Alternate Tree Representation There are several ways to represent a tree. Using the definition based on sets we could say that: T = {A, {G,{Y}}, {P,{K},{L}}, {W,{T},{C},{B}}} A A G P W Y K L T C B G P W Y K T C L B

21 Trees with Specific Number of Children

22 Trees with Specific Number of Children Binary Tree Each node has at most two children Quadree One left child One right child At most 4 children Octree At most 8 children M-ary tree At most M children

23 M-ary tree Examples Quadtree

24 M-ary tree Examples Octree

25 M-ary tree Examples Octree

26 The Tree Abstract Data Type Generic methods size(), isempty(), enumerate() Positional methods swapelement(p,q), replaceelement(p,n) Query methods isroot(), isleaf() Accessor methods root(), parent() children() Update methods() insert(p), delete(p)

27 The Tree Abstract Data Type parent Element childrencollection

28 Structure of a Binary Tree Node Nodes in binary trees have structure similar to linked list. Rather than a next and previous pointers, they maintain the following: Right: pointer the root of the right subtree Left: pointer to the the root of the left subtree Parent: pointer to the parent node parent left DATA right

29 Tree Traversal

30 Traversing Trees In general there are two ways of traversing trees Depth-based traversal: Level-order traversall

31 Cases of Depth-based Traversal There are three basic ways to traverse a tree using the a depth-based approach Preorder Inorder This search is better associated with binary trees Postorder This is what normally authors mean if they mention just depth-first search in the context of trees

32 Preorder Traversal A B C D E F G H I

33 Preorder Traversal A B C D E F G H I Result: A

34 Preorder Traversal A B C D E F G H I Result: AB

35 Preorder Traversal A B C D E F G H I Result: ABD

36 Preorder Traversal A B C D E F G H I Result: ABDE

37 Preorder Traversal A B C D E F G H I Result: ABDEH

38 Preorder Traversal A B C D E F G H I Result: ABDEHC

39 Preorder Traversal A B C D E F G H I Result: ABDEHCF

40 Preorder Traversal A B C D E F G H I Result: ABDEHCFG

41 Preorder Traversal A B C D E F G H I Result: ABDEHCFGI

42 Preorder Algorithm void preorder(tree t) { if (t!= null) { visit(t) preorder(t.getleft()) preorder(t.getright()) } }

43 Inorder Traversal A B C D E F G H I

44 Inorder Traversal A B C D E F G H I

45 Inorder Traversal A B C D E F G H I

46 Inorder Traversal A B C D E F G H I Result: D

47 Inorder Traversal A B C D E F G H I Result: DB

48 Inorder Traversal A B C D E F G H I Result: DB

49 Inorder Traversal A B C D E F G H I Result: DBH

50 Inorder Traversal A B C D E F G H I Result: DBHE

51 Inorder Traversal A B C D E F G H I Result: DBHEA

52 Inorder Traversal A B C D E F G H I Result: DBHEA

53 Inorder Traversal A B C D E F G H I Result: DBHEAF

54 Inorder Traversal A B C D E F G H I Result: DBHEAFC

55 Inorder Traversal A B C D E F G H I Result: DBHEAFCG

56 Inorder Traversal A B C D E F G H I Result: DBHEAFCGI

57 Inorder Algorithm void inorder(tree t) { if (t!= null) { inorder(t.getleft()) visit(t) inorder(t.getright()) } }

58 Postorder Traversal A B C D E F G H I

59 Postorder Traversal A B C D E F G H I Result:

60 Postorder Traversal A B C D E F G H I Result:

61 Postorder Traversal A B C D E F G H I Result: D

62 Postorder Traversal A B C D E F G H I Result: D

63 Postorder Traversal A B C D E F G H I Result: DH

64 Postorder Traversal A B C D E F G H I Result: DHE

65 Postorder Traversal A B C D E F G H I Result: DHEB

66 Postorder Traversal A B C D E F G H I Result: DHEB

67 Postorder Traversal A B C D E F G H I Result: DHEBF

68 Postorder Traversal A B C D E F G H I Result: DHEBF

69 Postorder Traversal A B C D E F G H I Result: DHEBFI

70 Postorder Traversal A B C D E F G H I Result: DHEBFIG

71 Postorder Traversal A B C D E F G H I Result: DHEBFIGC

72 Postorder Traversal A B C D E F G H I Result: DHEBFIGCA

73 Postorder Algorithm void postorder(tree t) { if (t!= null) { postorder(t.getleft()) postorder(t.getright()) visit(t) } }

74 Generic Traversal The depth-based traversals described are just a special case of the generic traversal for binary trees The Euler Tour Traversal It consists of walking around the tree and visiting each edge exactly 2 times times (or each node 3 times) A B C D E F G U P H R X N Q I W L

75 Level-order traversal A B C D E F G H I

76 Level-order traversal A B C D E F G H I Result: A

77 Level-order traversal A B C D E F G H I Result: AB

78 Level-order traversal A B C D E F G H I Result: ABC

79 Level-order traversal A B C D E F G H I Result: ABCD

80 Level-order traversal A B C D E F G H I Result: ABCDE

81 Level-order traversal A B C D E F G H I Result: ABCDEF

82 Level-order traversal A B C D E F G H I Result: ABCDEFG

83 Level-order traversal A B C D E F G H I Result: ABCDEFGH

84 Level-order traversal A B C D E F G H I Result: ABCDEFGHI

85 Full & Complete Trees A full binary tree is binary tree in which each node has exactly zero or two children. A perfect binary tree is one in which all the nodes except the leaves have exactly two children and all leaves are at the same level. A complete binary tree is one that is either full or full up to the last but one level, and have all the nodes in the bottommost level shifted to the left. A complete tree An incomplete tree

86 Array Implementation of Binary Trees There are several ways to implement a binary tree. Although it may appear that we must use pointers, this is not mandatory and other implementations may be more efficient depending on the tree structure. One way to represent binary trees is using arrays. For this to be possible we need to number the elements in such a way that operations to find the other nodes can be done in a systematic way One of best way to number the elements (nodes) is using a level-ordering approach. Start from the topmost number the node with 1, move down to the next level and number the nodes with 2 and 3 starting from the left, repeat the process until there are no more levels Similar to what level-order traversal does. Sequential representation is more cost-effective when the tree is complete

87 Level Order of a Binary Tree Given a complete binary tree as below if we perform the level-by-level numbering we get... Z F S G J H Q X C P

88 Level Order of a Binary Tree Given a complete binary tree as below if we perform the level-by-level numbering we get the level order numbering of all nodes. 1 2 Z 3 4 F 5 6 S 7 8 X G 9 C 1 0 P J H Q

89 Implementing Trees with Arrays By ordering a complete binary tree using level ordering we can see the relationship of the order and indexes of an array as below: Z F S G J H Q X C P Given the structure above, how do we find the nodes of the binary tree? 5 To find Use Provided The left child of bt[i] bt[2 * i] 2 * i <= n The right child of bt[i] bt[2 * i + 1] 2 * i + 1 <= n The parent of bt[i] bt[i / 2] i > 1 The root bt[1] bt is non-empty Whether bt[i] is leaf TRUE 2 * i > n

90 Binary Search Trees BSTs are binary trees where the nodes are organized as follows: All the elements in the left subtree of a node are less than the node All the elements in the right subtree of a node are greater than the node Both left and right subtrees are BSTs, meaning they have to conform to these properties Based on the description above you can see that BSTs do not accept repeated elements. The elements are all unique in value

91 Implementing Binary Search Trees The structure of a node for a binary search tree is very much like the structure for a doubly linked list. The main difference is that now from each node the references are interpreted differently: they are left or right This leads to the following definition for a node in a binary search tree (integer tree in this case) class NodeType { int data; // or other type NodeType left; NodeType right; NodeType parent; }

92 Searching in Binary Search Trees Searching is the reason we have BSTs. Like most operations in a BST, search is better described in a recursive fashion. The pseudo-code below describe the idea search (target) 1. If head of the tree is null return null; 2. Test whether the target is the same as the key in the head of the tree and return a pointer to the head if true 3. If not true, if target is less than the key in the head return the search of the target in the left subtree 4. If target is greater than the key in the head return the search of the target in the right subtree

93 search(10)

94 search(10)

95 search(10)

96 search(10)

97 search(10)

98 search(10)

99 search in (quasi-)java // Simplified idea of searching a binary search tree // You may (or may not) need to account for "special" // cases. Also the syntax is not necessarily correct it is simplified // to improve clarity NodeType search (NodeType link, int target) { if (link == null) return null; if (target == link.data) // Found the node return link; if (target < link.data) return search(link.left,target); // Try the left subtree else return search(link.right,target); // Try the right subtree }

100 Insertion in Binary Search Trees To insert an element in a BST we follow the same principle applied in the searching. Compare the value to be inserted with the current key and decide if the new element should be inserted on the left or on the right The element is always inserted as a leaf in the tree. insert (target) 1. If head of the tree is null create new node to store target; 2. Test whether the target is the same as the key in the head of the tree and return null (this means that the element cannot be added to the tree) 3. If not true, if target is less than the key in the head insert the target in the in the left subtree 4. If target is greater than the key in the head insert the target in the right subtree

101 insert(14)

102 insert(14)

103 insert(14)

104 insert(14)

105 insert(14)

106 Find Maximum Find maximum is another common operation in binary search trees and is helpful when implementing deletion. Again the recursive thinking makes this implementation much easier to understand The idea is simple. If a node has a non-null pointer to the right this node cannot be the maximum as the element in the right must be greater. findmax () 1. If head of the tree is null return null; 2. If the right pointer from the head is null head is the maximum 3. Else (it is not null) return the result of findmax in the right subtree

107 Find Minimum The idea of finding the minimum value in a binary search tree will also help the delete operation Its idea is very much like the maximum findmin () 1. If head of the tree is null return null; 2. If the left pointer from the head is null head is the minimum 3. Else (it is not null) return the result of findmin in the left subtree

108 Delete Deletion in BST is probably the least easy of the algorithms. The reason is that nodes can be deleted from anywhere, not only leaves. When inserting we know that we're not dealing with internal nodes and this make it straightforward When deleting a node we have two cases Deleting a leaf. This is easy. Since a leaf does not point to any other node we can just remove it from the tree Deleting from a internal node involves moving nodes around. The reason for this is that after the deletion the tree must still hold its's main property Let's see some examples

109 delete(10)

110 delete(10)

111 delete(10)

112 delete(10)

113 delete(10)

114 delete(10)

115 delete(9)

116 delete(9)

117 delete(9) What we need is move elements around so that the tree does not become disconnected and we keep the property of a BST This is not an option. You can see if we do this the tree is disconnected and we lose this part of the tree

118 delete(9) We can try to find an element below 9 that can be used in the position where 9 is If we want to maintain the property of the tree we have to options: either the maximum element of the left subtree or the minimum element of the right subtree

119 delete(9) Let us choose this one

120 delete(9) The number 3 is copied to the node where 9 was.

121 delete(9) This does not solve the problem because we now have two elements with the same value

122 delete(9) But we can solve the problem by deleting the number 3 from the left subtree of the current node (also 3)

123 delete(9)

124 delete(9)

125 delete(9)

126 Delete Delete can be made very simple if we implement functions like findmax, findmin and isleaf This code should make you appreciate recursion since it simplifies the job of deleting a node quite a lot. These function are used when deciding what to do. Using what we've discussed we can defined a pseudo-code for delete The elements return from findmax and findmin are equivalent to the in-order predecessor and in-order successor of the node being deleted.

127 Delete pseudo-code void delete (head,target) { if (head == null) return; if (target < head.key) delete (head.left,target); else if (target > head.key) delete(head.right,target); // element not in the list else delete if (isleaf(head)) { remove head from the tree else if (head.left!= null) { int max = findmax(head.left); head.key = max; delete(head.left,max); } else { int min = findmin(head.right); head.key = min; delete(head.right,min); } } // found the element to

128 Final comments about BSTs Desirable characteristics of a BST Most of operations can be done in O(h), where h is the height of the tree. In a random generated tree height is normally O (log n), where n is the number of nodes in the tree It can be used to help in other operations. For instance, sort a list. Undesirable characteristics The main one is that it may become unbalanced (possibly leading to something that looks like a linked list) which degrades all operations. To solve this problem we'll look at balanced trees Most of your operations are better understood recursively and we know that recursion is more expensive than iterative solutions

129 BST Exercise The concept of BST is quite common by interviewers because it is a simple concept and yet requires some thinking for some problems. Take for instance the following problem (which has been asked in at least 3 interview instances that I know of) The problem is Given an ordinary binary tree, test whether it is a BST.

130 Solution 1 Using findmin() and findmax() This is a modified version of findmax and findmin. Not the one described earlier. The tree may not be a BST. boolean isbst(tree node) { if (node==null) return true; // false if the max of the left is > than the current node if ((node.getleft()!=null) && ( findmax(node.getleft()) >= node.getvalue())) return false; // false if the min of the right is < than the current node if ((node.getright()!=null) && (findmin(node.getright()) <= node.getvalue())) return false; // false if the left node or right node are not a BST if (!isbst(node.getleft())!isbst(node.getright())) return false; // it is a BST if it gets here return true; }

131 Solution 2 Uses range of values. More efficient!!! int isbst(tree node) { // assuming MIN_VALUE and MAX_VALUE cannot be in the tree return isbstrange(node, MIN_VALUE, MAX_VALUE); } int isbstrange(tree node, int min, int max) { if (node==null) return true; // false if this value in current node violates the range constraints if (node.getvalue() <= min node.getvalue() => max) return false; // check the subtrees recursively, // range has to be modified with new range return isbstrange(node.getleft(), min, node.getvalue()) && isbstrange(node.getright(), node.getvalue(), max); }

132 Solution 3 I ll let you write the code. Do the inorder traversal of the tree and verify if the result is a sorted list.