1. Binary Trees Chapter 10

2. Introduction Previous chapter considered linked lists –nodes connected by two or more links We seek to organize data in a linked structure such that –it can be searched more efficiently –it can be used in new ways We begin with a review of search algorithms

3. Linear Search Collection of data items to be searched is organized in a list x 1, x 2, … x n –Assume = = and < operators defined for the type Linear search begins with item 1 –continue through the list until target found –or reach end of list

4. Linear Search Vector based search function template void LinearSearch (const vector &v, const t &item, boolean &found, int &loc) { found = false; loc = 0; for ( ; ; ) { if (found || loc == v.size()) return; if (item == x[loc]) found = true; else loc++; } }

5. Linear Search Singly-linked list based search function template void LinearSearch (NodePointer first, const t &item, boolean &found, NodePointer &locptr) { found = false; locptr = first; for ( ; ; ) { if (found || locptr == 0 ) return; if (item == locptr->data) found = true; else locptr = locptr->next; } } In both cases, the worst case computing time is still O(n)

6. Binary Search Binary search function for vector template void LinearSearch (const vector &v, const t &item, boolean &found, int &loc) { found = false; int first = 0; last = v.size() - 1; for ( ; ; ) { if (found || first > last) return; loc = (first + last) / 2; if (item v[loc]) first = loc + 1; else /* item == v[loc] */ found = true; } }

7. Binary Search Usually outperforms a linear search Disadvantage: –Requires a sequential storage –Not appropriate for linked lists (Why?) It is possible to use a linked structure which can be searched in a binary-like manner

8. Binary Search Tree Consider the following ordered list of integers 1.Examine middle element 2.Examine left, right sublist (maintain pointers) 3.(Recursively) examine left, right sublists 80666249352813

9. Binary Search Tree Redraw the previous structure so that it has a treelike shape – a binary tree 80 66 62 49 35 28 13

10. Trees A data structure which consists of –a finite set of elements called nodes or vertices –a finite set of directed arcs which connect the nodes If the tree is nonempty –one of the nodes (the root) has no incoming arc –every other node can be reached by following a unique sequence of consecutive arcs

11. Trees 80 66 62 49 35 28 13 70 Root node Children of the parent (66) Siblings to each other Leaf nodes

12. Binary Trees Each node has at most two children Useful in modeling processes where –a comparison or experiment has exactly two possible outcomes –the test is performed repeatedly Example –multiple coin tosses –encoding/decoding messages in dots and dashes such as Mores code

13. Array Representation of Binary Trees Store the i th node in the i th location of the array Works OK for complete trees, not for sparse trees U T P O E M C 0 1 2 3 4 5 6

14. Linked Representation of Binary Trees Uses space more efficiently Provides additional flexibility Each node has two links –one to the left child of the node –one to the right child of the node –if no child node exists for a node, the link is set to NULL data leftright left child right child

15. ADT Binary Search Tree (BST) Collection of Data Elements –binary tree –each node x, value in left child of x value in x in right child of x Basic operations –Construct an empty BST –Determine if BST is empty –Search BST for given item

16. ADT Binary Search Tree (BST) Basic operations (ctd) –Insert a new item in the BST Maintain the BST property –Delete an item from the BST Maintain the BST property –Traverse the BST Visit each node exactly once The inorder traversal must visit the values in the nodes in ascending order

17. BST Class Template template class BST { private: /* Node structure */ class BinNode { public: t data; BinNode *left, *right; BinNode() { left = right = 0; } BinNode (t item) { data = item; left = right = 0; } }; // end of class BinNode // ctd ->

18. BST Class Template... typedef BinNode *BinNodePointer; public: // for BST BST(); // construct an empty BST bool Empty() const; private: BinNodePointer root; }; // end of class template declaration

19. BST Class Template Definition of constructor template BST ::BST() { root = 0; } Definition of Empty() template bool BST ::Empty() { return root == 0; }

20. Searching a BST template bool BST ::Search(const t &item) const { BinNodePointer locptr = root; bool found = false; for ( ; ; ) { if found || locptr == 0) break; if (item data) locptr = locptr->left;// descend left else if (item > locptr->data) locptr = locptr->right;// descend right else found = true; } return found; } Reached a leaf node without finding a match

21. Inserting an Item into a BST template void BST ::Insert (const t &item) { BinNodePointer locptr = root; parent =0; bool found = false; for ( ; ; ) { if found || locptr == 0) break; parent = locptr; if (item data) locptr = locptr->left;// descend left else if (item > locptr->data) locptr = locptr->right;// descend right else found = true; } if (found) cerr << "Item already in the tree\n";...

22. Inserting an Item into a BST else { locptr = new BinNode (item); // construct node containing item if (parent == 0) // empty tree root = locptr; else if (item data) // insert left of parent parent->left = locptr else // insert right of parent parent->right = locptr; } // end of the else } end of the Insert

23. Problem of Lopsidedness Tree can be balanced –each node except leaves has exactly 2 child nodes Trees can be unbalanced –not all nodes have exactly 2 child nodes Trees can be totally lopsided –each node has a right child only –degenerates into a linked list

24. Problem of Lopsidedness Balanced tree search has O(log 2 n) –best case Tree degenerated into linked list has search O(n) –worst case Other unbalanced trees somewhere in between In general –Not possible to predict how to insert to create balanced tree –May require rebalancing algorithm

25. Binary Trees as Recursive Data Structures A binary tree is either empty … or Consists of –a node called the root –root has pointers to two disjoint binary (sub)trees called … right (sub)tree left (sub)tree Anchor Inductive step Which is either empty … or …

26. Tree Traversal is Recursive If the binary tree is empty then do nothing Else L: Traverse the left subtree N: Visit the root R: Traverse the right subtree The "anchor" The inductive step

27. Traversal Order Three possibilities for inductive step … Left subtree, Node, Right subtree the inorder traversal Node, Left subtree, Right subtree the preorder traversal Left subtree, Right subtree, Node the postorder traversal

28. Traversal Order Given expression A – B * C + D Represent each operand as –the child of a parent node –representing the corresponding operator +-DA*BC

29. Traversal Order Inorder traversal produces infix expression A – B * C + D Preorder traversal produces the prefix expression + - A * B C D Postorder traversal produces the postfix or RPN expression A B C * - D +

30. Traversing a Binary Tree template void BST ::Inorder(ostream &out) { InorderAux (out, root); } template void BST ::InorderAux (ostream& out, BinNodePointer ptr) { if (ptr != 0) { InorderAux (opt, ptr->left); out data right); } Two functions needed: We can send a message to a BST object … but … Cannot send a message to its root, required by recursion Inorder sends message to the root Two functions needed: We can send a message to a BST object … but … Cannot send a message to its root, required by recursion Inorder sends message to the root Change order of these three statements for different traversals Change order of these three statements for different traversals

31. Recursive Searching template bool BST ::Search (const t &item) { return SearchAux (root, item); } template bool BST ::SearchAux (BinNodePointer locptr, const t &item) { if (locptr == 0) return false; // empty tree if (item data) return SearchAux(locptr->left, item); else if (item > locptr->data) return SearchAux (locptr->right, item); else return true; } Author suggests iterative approach is easier, just as efficient iterative approach Author suggests iterative approach is easier, just as efficient iterative approach

32. Recursive Insertion template void BST ::Insert (const t &item) { InsertAux (root, item); } template (typename t> void BST ::InsertAux (BinNodePointer &locptr, const t &item) { if (locptr == 0) locptr = new BSTNode (item); else if (item data) InsertAux (locptr->left, item); else if (item > locptr->data) InsertAux (locptr->right, item); else cerr << "Item already in tree\n"; }

33. Deletion Three possible cases to delete a node, x, from a BST The node, x, is a leaf x has one child x has two children Note the source code for the deletion function, pgs 548 - 550

34. Deletion What steps must be done to remove a leaf node? class BST { private: /* Node structure */ class BinNode { public: t data; BinNode *left, *right; BinNode() { left = right = 0; } BinNode (t item) { data = item; left = right = 0; } }; // end of class BinNode... ← x

35. Deletion What steps must be done to remove a node with 1 child? class BST { private: /* Node structure */ class BinNode { public: t data; BinNode *left, *right; BinNode() { left = right = 0; } BinNode (t item) { data = item; left = right = 0; } }; // end of class BinNode... x →

36. Deletion What steps must be done to remove a node with 2 children? class BST { private: /* Node structure */ class BinNode { public: t data; BinNode *left, *right; BinNode() { left = right = 0; } BinNode (t item) { data = item; left = right = 0; } }; // end of class BinNode... x → Strategy: Replace with its inorder successor or predecessor Successor – right child, descend left Predecessor – left child, descend right