CPSC 221: Data Structures Lecture #5. CPSC 221: Data Structures Lecture #5. Learning Goals. Today s Outline. Tree Terminology.

Transcription

1 PS 1: Data Structures ecture # ranching Out Steve Wolfman 0W1 PS 1: Data Structures ecture # ranching Out Steve Wolfman 0W1 earning Goals fter this unit, you should be able to... Determine if a given tree is an instance of a particular type (e.g. binary search tree, heap, etc.) Describe and use pre-, in- and post-order traversal algorithms Describe the properties of binary trees, binary search trees, and more general trees; mplement iterative and recursive algorithms for navigating them in ++ ompare and contrast ordered versus unordered trees in terms of complexity and scope of application nsert and delete elements from a binary tree inary Trees Dictionary DT inary Search Trees Trees Tree Terminology Family Trees Organization harts lassification trees what kind of flower is this? is this mushroom poisonous? File directory structure folders, subfolders in Windows directories, subdirectories in UX on-recursive procedure call chains root: leaf: child: parent: sibling: ancestor: descendent: subtree: 6

2 Tree Terminology Reference ore Tree Terminology root: the single node with no parent leaf: a node with no children child: a node pointed to by me parent: the node that points to me sibling: another child of my parent ancestor: my parent or my parent s ancestor descendent: my child or my child s descendent subtree: a node and its descendents depth: # of edges along path from root to node depth of? a. 0 b. 1 c. d. 3 e. 4 We sometimes use degenerate versions of these definitions that allow U as the empty tree. (This can be very handy for recursive base cases!) 8 ore Tree Terminology ore Tree Terminology height: # of edges along longest path from node to leaf or, for whole tree, from root to leaf height of tree? a. 0 b. 1 c. d. 3 e. 4 degree: # of children of a node degree of? a. 0 b. 1 c. d. 3 e. 4 ore Tree Terminology branching factor: maximum degree of any node in the tree for binary trees, our usual concern; for this weird tree One ore Tree Terminology Slide binary: branching factor of (each child has at most children) n-ary: branching factor of n complete: packed binary tree; as many nodes as possible for its height D E F G 11 1 nearly complete: complete plus some nodes on the left at the bottom

3 Tree alculations Tree alculations Example Find the longest undirected path in a tree ight be: t inary Trees Dictionary DT inary Search Trees inary Trees inary tree is a root recursive definition! left subtree (maybe empty) right subtree (maybe empty) Properties max # of leaves: max # of nodes: average depth for nodes: Representation: D E G F Data left pointer right pointer D E Representation F struct ode { TYPE key; DTYPE data; ode * left; ode * right; ; D E F inary Trees Dictionary DT inary Search Trees

4 What We an Do So Far Dictionary DT Stack Push Pop Queue Enqueue Dequeue ist nsert Remove Find Priority Queue nsert Deletein Dictionary operations create destroy insert find delete insert brownies - tasty find(wolf) wolf - the perfect mix of oomph and Scrabble value midterm would be tastier with brownies prog-project so painful who invented templates? wolf the perfect mix of oomph and Scrabble value What s wrong with ists? Stores values associated with user-specified keys values may be any (homogenous) type keys may be any (homogenous) comparable type Dictionary operations create destroy insert find delete Search DT Stores keys keys may be any (homogenous) comparable quickly tests for membership insert in Pin find(wolf) OT FOUD erner Whippet lsatian Sarplaninac eardie Sarloos alamute Poodle odest Few Uses rrays and ssociative rrays Sets Dictionaries Router tables Page tables Symbol tables ++ Structures Desiderata aïve mplementations insert find delete Fast insertion runtime: inked list Fast searching runtime: Fast deletion runtime: Unsorted array Sorted array so close!

5 inary Trees Dictionary DT inary Search Trees inary Search Tree Dictionary Data Structure inary tree property each node has 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 ounter-example n Order isting 1 struct ode { TYPE key; DTYPE data; ode * left; ode * right; ; RY SER TREE OT RY SER TREE 1 n order listing: 1 1 Finding a ode Finding a ode 1 a. O(1) b. O(lg n) c. O(n) runtime: d. O(n lg n) e. one of these ode *& find(omparable key, ode *& root) { if (root == U) if (key < root->key) return find(key, root->left); if (key > root->key) return find(key, root->right); 1 WRG: uch fancy footwork with refs (&) coming. You can do all of this without refs... just watch out for special cases. ode *& find(omparable key, ode *& root) { if (root == U) if (key < root->key) return find(key, root->left); if (key > root->key) return find(key, root->right);

6 terative Find nsert ode * find(omparable key, ode * root) { while (root!= U && root->key!= key) { if (key < root->key) 1 1 void insert(omparable key, ode * root) { ode *& target(find(key, root)); assert(target == U); root = root->left; root = root->right; target = new ode(key); (t s trickier to get the ref return to work here.) ook familiar? runtime: Funky game we can play with the *& version. 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 onst reference parameters (const Object & foo) shares parameter cannot affect actual value use when the value is too intricate for pass-by-value uildtree for STs Suppose the data 1,, 3, 4,, 6,, 8, is inserted into an initially empty ST: in order in reverse order median first, then left median, right median, etc. nalysis of uildtree onus: Findin/Findax Worst case: O(n ) as we ve seen verage case assuming all orderings equally likely turns out to be O(n lg n). Find minimum 1 Find maximum

7 Double onus: Successor ore Double onus: Predecessor Find the next larger node in this node s subtree. Find the next smaller node in this node s subtree. ode *& succ(ode *& root) { if (root->right == U) return root->right; return min(root->right); ode *& min(ode *& root) { if (root->left == U) return min(root->left); 1 ode *& pred(ode *& root) { if (root->left == U) 1 return root->left; return max(root->left); ode *& max(ode *& root) { if (root->right == U) return min(root->right); inary Trees Dictionary DT inary Search Trees Deletion 1 Why might deletion be harder than insertion? azy Deletion nstead of physically deleting nodes, just mark them as deleted + simpler + physical deletions done in batches + some adds just flip deleted flag extra memory for deleted flag many lazy deletions slow finds some operations may have to be modified (e.g., min and max) 1 Delete(1) Delete(1) Delete() Find() Find(16) nsert() Find(1) azy Deletion 1

8 Deletion - eaf ase Deletion - One hild ase Delete(1) Delete(1) 1 1 Deletion - Two hild ase Finally Delete() Delete ode ORRETED from printed version void delete(omparable key, ode *& root) { ode *& handle(find(key, root)); ode * todelete = handle; if (handle!= U) { if (handle->left == U) { // eaf or one child handle = handle->right; if (handle->right == U) { // One child handle = handle->left; { // Two child case ode *& successor(succ(handle)); handle->data = successor->data; todelete = successor; successor = successor->right; // Succ has <= 1 child delete todelete; Refs make this short and elegant but could be done without them with a bit more work. inary Trees Dictionary DT inary Search Trees

9 Thinking about inary Search Trees Observations Each operation views two new elements at a time Elements (even siblings) may be scattered in memory inary search trees are fast if they re shallow Realities For large data sets, disk accesses dominate runtime Some deep and some shallow STs exist for any data Reduce disk accesses? eep STs shallow? Solutions? One more piece of bad news: what happens to a balanced tree after many insertions/deletions? To Do Finish Project # (due Oct 8!) Start W#3 (out soon) Start Project #3 (out soon) Read Epp 11. and W oming Up Self-balancing inary Search Trees uge Search Tree Data Structure