1. CSE 326: Data Structures Lecture #7 Branching Out Steve Wolfman Winter Quarter 2000

2. Today’s Outline Talking about HW #2 Some Tree Review Binary Trees Dictionary ADT Binary Search Trees

3. HW #2 Solutions are online –www.cs.washington.edu/326 –navigate to assignments Good work! If you got 5/8 or less, come talk to us If you don’t understand anything on the quiz, come talk to us or e-mail us (owner-cse326@cs) –understand the solution even if you got it right on the quiz! Problems #3 and #8

4. Problem #3 int Albatross(int n) If n=1 Then Return End If For i=1 to n Print ``Do you see the albatross now?'' End For Albatross(n/2)

5. Problem #8: How is a Queue like a Stack like a Priority Queue? Similar –store collections of elements –all elements of the same type –support an inserting operator and a removing operator –define a structured ordering on the removal of elements (I.e., not random) Different –a priority queue is not a queue! –very different orderings on elements –pqueues require comparisons on the elements –stacks and queues are highly efficient (pqueues slightly less so) –theoretical computational power (pqueues and queues beat stacks

6. Tree Calculations Find the longest undirected path in a tree Might be: – the longest path in one of the subtrees – the longest path that goes through t t

7. Tree Calculations Example A E B DF C G IH KJL M L N

8. Binary Trees Binary tree is –a root –left subtree (maybe empty) –right subtree (maybe empty) Properties –max # of leaves: –max # of nodes: –average depth for N nodes: Representation: A B DE C F HG JI Data right pointer left pointer

9. Representation A right pointer left pointer A B DE C F B right pointer left pointer C right pointer left pointer D right pointer left pointer E right pointer left pointer F right pointer left pointer

10. What We Can Do So Far Stack –Push –Pop Queue –Enqueue –Dequeue What’s wrong with Lists? Remember decreaseKey? List –Insert –Remove –Find Priority Queue –Insert –DeleteMin

11. Dictionary ADT Dictionary operations –create –destroy –insert –find –delete Stores values associated with user-specified keys –values may be any (homogenous) type –keys may be any (homogenous) comparable type Zasha –interesting ID, but not enough ooomph! Bone –More oomph, less high scoring Scrabble action Wolf –the perfect mix of oomph and Scrabble value insert find(Wolf) Darth - formidable Wolf - the perfect mix of oomph and Scrabble value

12. Search ADT Dictionary operations –create –destroy –insert –find –delete Stores keys –keys may be any (homogenous) comparable –quickly tests for membership Berner Whippet Alsatian Sarplaninac Beardie Sarloos Malamute Poodle insert find(Wolf) Min Pin NOT FOUND

13. A Modest Few Uses Arrays Sets Dictionaries Router tables Page tables Symbol tables C++ Structures

14. Desiderata Fast insertion –runtime: Fast searching –runtime: Fast deletion –runtime:

15. Naïve Implementations Linked list Unsorted array Sorted array insert delete find so close!

16. Binary Search Tree Dictionary Data Structure 4 121062 115 8 14 13 79 Binary tree property –each node has  2 children –result: storage is small operations are simple average depth is small Search tree property –all keys in left subtree smaller than root’s key –all keys in right subtree larger than root’s key –result: easy to find any given key

17. Example and Counter-Example 3 1171 84 15 4 181062 115 8 20 21 BINARY SEARCH TREE NOT A BINARY SEARCH TREE 7 15

18. In Order Listing 2092 155 10 307 17 In order listing: 2  5  7  9  10  15  17  20  30

19. Finding a Node Node *& find(Comparable key, Node *& root) { if (root == NULL) return root; else if (key key) return find(key, root->left); else if (key > root->key) return find(key, root->right); else return root; } 2092 155 10 307 17 runtime:

20. Iterative Find Node * find(Comparable key, Node * root) { while (root != NULL && root->key != key) { if (key key) root = root->left; else root = root->right; } return root; } Look familiar? 2092 155 10 307 17

21. Insert 2092 155 10 307 17 runtime: void insert(Comparable key, Node * root) { Node *& target(find(key, root)); assert(target == NULL); target = new Node(key); }

22. Digression: Value vs. Reference Parameters Value parameters (Object foo) –copies parameter –no side effects Reference parameters (Object & foo) –shares parameter –can affect actual value –use when the value needs to be changed Const reference parameters (const Object & foo) –shares parameter –cannot affect actual value –use when the value is too intricate for pass-by-value

23. BuildTree for BSTs Suppose the data 1, 2, 3, 4, 5, 6, 7, 8, 9 is inserted into an initially empty BST: –in order –in reverse order –median first, then left median, right median, etc.

24. Analysis of BuildTree Worst case: O(n 2 ) as we’ve seen Average case assuming all orderings equally likely:

25. Bonus: FindMin/FindMax Find minimum Find maximum 2092 155 10 307 17

26. To Do Start Project II Answer the Quiz questions you missed Read chapter 4 in the book

27. Coming Up A bit more Binary Search Trees Self-balancing Binary Search Trees Huge Search Tree Data Structure Third homework assignment due (January 26th) Second project due (January 28th)