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

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

HW #2 Solutions are online – –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 us –understand the solution even if you got it right on the quiz! Problems #3 and #8

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)

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

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

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

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

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

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

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

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

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

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

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

Binary Search Tree Dictionary Data Structure 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

Example and Counter-Example BINARY SEARCH TREE NOT A BINARY SEARCH TREE 7 15

In Order Listing In order listing: 2  5  7  9  10  15  17  20  30

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; } runtime:

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?

Insert runtime: void insert(Comparable key, Node * root) { Node *& target(find(key, root)); assert(target == NULL); target = new Node(key); }

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

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.

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

Bonus: FindMin/FindMax Find minimum Find maximum

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

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)