Binomial Queue deletemin ADTs Seen So Far

Transcription

1 Today s Outline Trees (inary Search Trees) hapter in Weiss S ata Structures Ruth nderson nnouncements Written HW # due next riday, 1/ Project due next Monday, /1 Today s Topics: Priority Queues inomial Queues ictionary T inary Search Trees 1//0 1//0 1 inomial Queue deletemin 1-1 Ts Seen So ar 1 Stack Push Pop Priority Queue Insert eletemin Queue nqueue equeue Remember decreasekey? 1//0 ctivity 1//0 The ictionary T: Modest ew Uses ssociates a key with a value Main operations: ind, Insert, elete xamples: Networks Operating systems ompilers : Router tables : Page tables : Symbol tables Probably the most widely used T! Tree alculations Recall: height is max number of edges from root to a leaf ind the height of the tree... runtime: t 1//0 1//0

2 Tree alculations xample How high is this tree? G H I More Recursive Tree alculations: Tree Traversals + traversal is an order for visiting all the nodes of a tree Three types: Pre-order: Root, left subtree, right subtree * (an expression tree) J K L L M 1//0 N In-order: Left subtree, root, right subtree Post-order: Left subtree, right subtree, root 1//0 ctivity Traversals inary Trees void traverse(node t){ if (t!= NULL) traverse (t.left); print t.element; traverse (t.right); Which one is this? inary tree is a root left subtree (maybe empty) right subtree (maybe empty) Representation: ata I G J H 1//0 1//0 inary Tree: Representation inary Tree: Special ases G G omplete Tree Perfect Tree H I ull Tree 1//0 1//0 1

3 inary Tree: Some Numbers! The ictionary T or binary tree of height h: max # of leaves: max # of nodes: min # of leaves: min # of nodes: ata: a set of (key, value) pairs Operations: Insert (key, value) ind (key) Remove (key) insert(rea,.) find(dcjones) dcjones aniel Jones, rea Ruth nderson OH: MW : S 0 dcjones aniel Jones OH: 1:-: S 1 1//0 1 ctivity The ictionary T is sometimes 1//0 called the Map T 1 The ictionary T: Modest ew Uses ssociates a key with a value Main operations: ind, Insert, elete Implementations insert find Unsorted Linked-list delete xamples: Networks Operating systems ompilers : Router tables : Page tables : Symbol tables Unsorted array Sorted array Probably the most widely used T! 1//0 1 1//0 1 inary Search Tree ata Structure re these STs? Structural property each node has children result: storage is small operations are simple average depth is small Order 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 What must I know about what I store? 1// //0 1 0 ctivity

4 ind in ST, Recursive ind in ST, Iterative Runtime: Node ind(object key, Node root) { if (root == NULL) return NULL; if (key < root.key) return ind(key, root.left); else if (key > root.key) return ind(key, root.right); else return root; 1//0 1 Node ind(object key, Node root) { while (root!= NULL && root.key!= key) { if (key < root.key) root = root.left; else root = root.right; return root; 1//0 0 Runtime: Insert in ST uildtree for ST 1 0 Insert(1) Insert() Insert(1) Suppose keys 1,,,,,,,, are inserted into an initially empty ST. Runtime depends on the order! in given order 1 in reverse order Runtime: median first, then left median, right median, etc. 1//0 1 ctivity 1//0 onus: indmin/indmax eletion in ST ind minimum 1 ind maximum Why might deletion be harder than insertion? 1//0 1//0

5 Instead of physically deleting nodes, just mark them as deleted Lazy eletion + 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// Non-lazy eletion Removing an item disrupts the tree structure. asic idea: find the node that is to be removed. Then fix the tree so that it is still a binary search tree. Three cases: node has no children (leaf node) node has one child node has two children 1//0 Non-lazy eletion The Leaf ase eletion The One hild ase elete(1) elete(1) //0 1//0 eletion The Two hild ase eletion The Two hild ase elete() 0 Idea: Replace the deleted node with a value guaranteed to be between the two child subtrees! Options: succ from right subtree: findmin(t.right) pred from left subtree : findmax(t.left) What can we replace with? Now delete the original node containing succ or pred Leaf or one child case easy! 1//0 1//0

6 inally alanced ST replaces 0 Observation ST: the shallower the better! or a ST with n nodes verage height is O(log n) Worst case height is O(n) Simple cases such as insert(1,,,..., n) lead to the worst case scenario Original node containing gets deleted 1//0 1 Solution: Require a alance ondition that 1. ensures depth is O(log n) strong enough!. is easy to maintain not too strong! 1//0 Potential alance onditions 1. Left and right subtrees of the root have equal number of nodes Potential alance onditions. Left and right subtrees of every node have equal number of nodes. Left and right subtrees of the root have equal height. Left and right subtrees of every node have equal height 1//0 1//0 ctivity The VL alance ondition Left and right subtrees of every node have equal heights differing by at most 1 efine: balance(x) = height(x.left) height(x.right) VL property: 1 balance(x) 1, for every node x nsures small depth Will prove this by showing that an VL tree of height h must have a lot of (i.e. O( h )) nodes asy to maintain Using single and double rotations 1//0 The VL Tree ata Structure Structural properties 1. inary tree property. alance property: balance of every node is between -1 and 1 Result: Worst case depth is O(log n) Ordering property Same as for ST 1//

7 1 Proving Shallowness ound Let S(h) be the min # of nodes in an VL tree of height h laim: S(h) = S(h-1) + S(h-) + 1 Solution of recurrence: S(h) = O( h ) (like ibonacci numbers) VL tree of height h= with the min # of nodes 1 1// //0 1 Testing the alance Property n VL Tree 1 0 We need to be able to: data height children NULLs have height -1 1//0 1//0 0