1 Binary trees. 1 Binary search trees. 1 Traversal. 1 Insertion. 1 An empty structure is an empty tree.

Size: px

Start display at page:

Download "1 Binary trees. 1 Binary search trees. 1 Traversal. 1 Insertion. 1 An empty structure is an empty tree."

Gerard Stokes
5 years ago
Views:

Unit 6: Binary Trees Part 1 Engineering 4892: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland July 11, 2011 1 Binary trees 1 Binary search trees Analysis

structures, but they are unable to represent a hierarchical collection of objects. Thus we introduce trees. A tree consists of nodes which are connected together by arcs.

1 Unit 6: Binary Trees Part 1 Engineering 4892: Data Structures Faculty of Engineering & Applied Science Memorial University of Newfoundland July 11, Binary trees 1 Binary search trees Analysis of BST search 1 Traversal 1 Insertion ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 Binary trees Linked lists are very useful data structures, but they are unable to represent a hierarchical collection of objects. Thus we introduce trees. A tree consists of nodes which are connected together by arcs. By contrast to a natural tree, such as a Maple tree, a tree is drawn upside-down: If two nodes are joined by an arc, the upper node is the parent while the lower node is a child. (The definition of upper is made more precise below). There is one special node called the root, which has no parent. On the other hand, leaves (a.k.a terminal nodes) are nodes that have no children. We can define a tree as follows: (repeated verbatim from the text) 1 An empty structure is an empty tree. 2 If t 1,..., t k are disjointed trees, then the structure whose root has as its children the roots of t 1,... t k is also a tree. 3 Only structures generated by rules 1 and 2 are trees. The number of arcs in a path from the root to a node is the length of the path. The level of a node is the length of the path to the root plus one (i.e. the number of nodes along the path). Nodes Level , 12, , 25, 29, 31 3

2 The height is the maximum level of a node in the tree. The height of the tree on the previous page is 3. The height of the empty tree is 0. A complete binary tree is a tree where all nodes have two children except those at the last level which have none: We will focus on binary trees for which all nodes have two children (one or both of which may be empty). Also, each child is designated as the left or right child. At level i of a complete binary tree there are 2 i 1 nodes. In any binary tree there are a maximum of 2 i 1 nodes at level i. Because of their recursive structure, trees are often amenable to inductive reasoning. e.g. A decision tree is a binary tree in which all nodes have either 0 or 2 children. We will prove the following conjecture about decision trees: Conjecture For a decision tree with L leaves and I nonterminal nodes, L = I + 1. Base Case: A one-node tree. We have one leaf (L = 1) and 0 nonterminal nodes (I = 0). The conjecture holds. Inductive Case: Assume the conjecture is true for a tree of size n. We now add two nodes to the tree. For it to remain a decision tree, they must be added to the same node, which must currently be a leaf. Thus, we have lost one leaf, but gained two: L = L = L + 1. (repeating from previous slide) L = L + 1 I = I + 1 How does L relate to I? L = L + 1 L = (I + 1) + 1 (inductive hypothesis) L = I + 1 The conjecture is true for a tree of size n + 2. By induction the conjecture is true for any decision tree. We have also gained one nonterminal node: I = I + 1.

In a binary search tree (BST) all values stored in the left subtree of a node N are less than the value v stored at N, and all nodes in the right subtree have values greater than v.

3 Binary search trees The relationship leaves = nonterminals + 1, which holds for decision trees, applies also to complete binary trees (why?). The number of leaves in a complete binary tree is 2 h 1, where h is the height of the tree. In a binary search tree (BST) all values stored in the left subtree of a node N are less than the value v stored at N, and all nodes in the right subtree have values greater than v. We will assume that a BST contains no duplicate nodes. Thus, the number of nonterminals is 2 h 1 1. The total number of nodes is, n = 2 h h 1 1 = 2 h 1 We can now relate the height of a complete tree to n: h = lg(n + 1). The ordering of nodes is given by the ordering of their values (which may be alphabetical, as for (a) and (b) above). ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 Which of the following is a BST? How can we implement a BST? One possibility is with an array. At each position in the array we store the node s data, plus the index of its left and right children (-1 if empty): The tree on the left is not a BST. Although every node has the appropriate relationship to its parent, a BST requires that the root node s value be greater than all values in the left subtree. The 30 node is out of place with respect to the 20. The tree on the right is a BST. ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33

4 This strategy has some clear disadvantages: We must know the size beforehand (although we could use a vector) Deletion requires either leaving a hole in the array, or modifying possibly all array entries. Generally a pointer-based implementation is preferred. We will create a BST class that stores instances of BSTNode... class BSTNode { public : BSTNode ( ) { left = right = 0 ; BSTNode ( const T& el, BSTNode l = 0, BSTNode r = 0) { key = el ; left = l ; right = r ; T key ; BSTNode left, right ; ; class BST { public : BST ( ) { root = 0 ;... bool isempty ( ) const { return root == 0 ;... void insert ( const T &); T search ( const T& el ) const { return search ( root, el ) ;... protected : BSTNode<T> root ;... T search ( BSTNode<T>, const T&) const ; ; How do we find a particular element in a BST? Exhaustive search is possible, but the whole point of a BST is to provide improved efficiency for search. Consider searching for Hermione in the following tree: Start at Harry : Hermione > Harry therefore we search in Harry s right subtree. Hermione < Ron therefore we search in Ron s left subtree. Hermione = Hermione therefore we stop searching!

5 The following function implements search: T BST<T >:: search ( BSTNode<T> p, const T& el ) const { while ( p!= 0) if ( el == p >key ) return &p >key ; else if ( el < p >key ) p = p >left ; else p = p >right ; return 0 ; Note: This returns the first node that matches el. If there were other duplicate matches, we would never access them. Hence, we do not allow duplicate nodes in our BST. ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 Analysis of BST search Consider searching the following tree: To determine the complexity of search we will count the number of comparisons between nodes. If we search for 13 only one comparison is required. If we search for 29 we require the maximum number of 4 comparisons. 4 comparisons are also required in a failed search for any possible children of 29: 26, 27, 28, 30. In general, the complexity is given by the number of nodes along the search path. This is the path length plus 1. The complexity is governed by two factors: The shape of the tree The position of the sought node within the tree We will consider worst and best case analysis for the shape of the tree. For the position of the sought node, we will stick with worst case analysis (the book employs average case). This implies searching for a node that is on level h of the tree. Worst Case Tree Shape: All nonterminals have one child only. Thus, the tree is effectively a linked list. The number of comparisons required is h = n. Thus search is O(n). Best Case Tree Shape: The height of the tree is minimized. This means that the leaves of the tree are on at most two levels. This case is a bit hard to analyze, so we assume that the tree is complete (requires n = 2 h 1). The height of the tree is h = lg(n + 1). Thus, search is O(lg n). Analyzing the average tree shape is more difficult. However, it can be shown that the average height of a randomly built BST is O(lg n). Thus, search is O(lg n) for such a tree. ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33

6 Traversal Breadth-First Traversal We wish to go downwards the tree level by level and visit each node in left-to-right order. For example, As opposed to searching for a particular value in a tree, we may wish to perform some operation on each node. For example, we may wish to print the contents of each node, decrement the value stored at each node, etc... We will simply say that we wish to visit each node. In what order shall we visit the tree s nodes? There are n! possible different orderings, but only some of these orderings are useful. We will consider the most common... Left-to-right, breadth-first traversal: 13, 10, 25, 2, 12, 20, 31, 29. ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 The following is the code for left-to-right breadth-first traversal: The implementation for a left-to-right breadth-first traversal requires a queue. We do the following, while the queue is not empty: dequeue the next node visit this node enqueue its left child (if it exists) enqueue its right child (if it exists) If we are considering a node on level n of the tree, we will first visit the node and then enqueue its children which are at level n + 1. Any other nodes at level n will be visited before reaching any of the nodes on level n + 1. Thus, the traversal proceeds in a breadth-first top-down manner. void BST<T >:: breadthfirst ( ) { Queue<BSTNode<T> > queue ; BSTNode<T> p = root ; queue. enqueue ( p ) ; while (! queue. empty ( ) ) { p = queue. dequeue ( ) ; if ( p >left!= 0) queue. enqueue ( p >left ) ; if ( p >right!= 0) queue. enqueue ( p >right ) ; ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33

7 We use the STL queue, customized slightly so that enqueue exists and dequeue is defined such that it both removes the front item from the queue and also returns its value. class Queue : public queue<t> { public : T dequeue ( ) { T tmp = queue<t >:: front ( ) ; queue<t >:: pop ( ) ; return tmp ; void enqueue ( const T& el ) { push ( el ) ; ; ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 Depth-First Traversal We descend down to the leftmost (or rightmost) leaf. We then back up to the last node where a choice between two branches exists and explore the other branch. At each node we have three operations to perform: V - visit the node L - traverse the left subtree R - traverse the right subtree There are 3! ways of ordering these three operations: VLR, VRL, LVR, LRV, RVL, RLV. It is most common to traverse in left-to-right order. This gives us three depth-first traversals with special names: VLR - preorder traversal LVR - inorder traversal LRV - postorder traversal Preorder: Inorder: Postorder: The following recursive functions implement these traversals: void BST<T >:: inorder ( BSTNode<T> p ) { inorder ( p >left ) ; inorder ( p >right ) ; void BST<T >:: preorder ( BSTNode<T> p ) { preorder ( p >left ) ; preorder ( p >right ) ; void BST<T >:: postorder ( BSTNode<T> p ) { postorder ( p >left ) ; postorder ( p >right ) ;

8 These recursive functions are short and elegant. However, we may wish to consider using iterative versions. The following is an iterative preorder traversal: void BST<T >:: iterativepreorder ( ) { Stack<BSTNode<T> > travstack ; BSTNode<T> p = root ; travstack. push ( p ) ; while (! travstack. empty ( ) ) { p = travstack. pop ( ) ; if ( p >right!= 0) travstack. push ( p >right ) ; if ( p >left!= 0) travstack. push ( p >left ) ; The iterative versions of postorder and inorder traversal are more complicated. Like iterativepreorder they require the use of a stack. The book discusses other traversal strategies that do not require the use of a stack. That is, neither the run-time stack through recursion, nor an explicit stack as in iterativepreorder are required. However, these strategies are beyond the scope of this course. ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33 Insertion Inserting a new node into a BST is a relatively simple operation. We simply search for the position in the tree where the item would be stored if it had already been added. Then we add it in that position. Consider adding Lupin to the following BST: Consider the path followed in searching for Lupin : Harry, Ron, Hermione... Lupin > Hermione therefore we search in Hermione s right subtree....but Hermione has no right subtree! So this must be where Lupin goes. The code for insertion begins similarly to search. However, once we find the null position where the new node should go, we must perform the insertion. This requires knowing the parent of the null position. The prev pointer is used to keep track of this node... ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33

9 void BST<T >:: insert ( const T& el ) { BSTNode<T> p = root, prev = 0 ; while ( p!= 0) { // f i n d p l a c e f o r i n s e r t i o n prev = p ; if ( p >key < el ) p = p >right ; else p = p >left ; if ( root == 0) // t r e e i s empty ; root = new BSTNode<T>(el ) ; else if ( prev >key < el ) prev >right = new BSTNode<T>(el ) ; else prev >left = new BSTNode<T>(el ) ; ENGI 4892 (MUN) Unit 6, Part 1 July 11, / 33

Data Structures And Algorithms

Data Structures And Algorithms Binary Trees Eng. Anis Nazer First Semester 2017-2018 Definitions Linked lists, arrays, queues, stacks are linear structures not suitable to represent hierarchical data,