CPSC 223 Algorithms & Data Abstract Structures

Transcription

1 PS 223 lgorithms & ata bstract Structures Lecture 17: Self-alancing inary Search Trees * Material adapted from. arrano, K. Yerion, and K. ant Today Quiz alanced inary Search Trees (STs) Quick review of terminology Heaps as a balanced tree structure brute-force self-balancing ST VL Trees PS 223,

2 Self-alancing inary Search Trees Recall that in a ST epending on the order of insertion we may end up with a structure that is not tree-like Insert: Insert: In these (worst) cases O(n) to find (lookup/retrieve) a node w/ matching search key nd thus O(n) to insert and delete We can do better by keeping the tree balanced PS 223, inary Trees ( from Lecture 6) The height of a tree is the length of the longest path i.e., the number of nodes that lie on the longest path from the root to a leaf the height of this tree is 3 G PS 223,

3 inary Trees ( from Lecture 6) full binary tree has a height h with no missing nodes i.e., every internal node has exactly 2 children complete binary tree of height h is a full binary tree at height h 1, and the nodes at height h are filled in from left to right G this is a full binary tree this is a complete binary tree PS 223, Minimum Height Trees ull and complete binary trees are of minimum height log 2 (n+1) = minimum height of a binary tree log 2 (7+1) = 3 log 2 (6+1) = 3 G this is a full binary tree this is a complete binary tree PS 223,

4 inary Trees ( from Lecture 6) balanced binary tree has for every node left and right subtrees that differ in height by at most 1 h = 3 balance factor of 3 (lem height) 1 (right height) = 2 h = 1 this is not a balanced binary tree balance factor of 3 2 = 1 h = 3 h = 2 this is a balanced binary tree alanced = balance factor of 1, 0, or 1 G PS 223, inary Trees ( from Lecture 6) re all balanced binary trees of minimum height? NO! eing balanced does not imply minimum height ut, balanced trees still have a height that is O(log n) This is a subtle point It means we do not need to maintain strictly complete trees log 2 (7+1) = 3! this is a balanced binary tree G PS 223,

5 11/10/09 Heaps Revisited oolness of heaps: They remain complete (i.e., of minimum height).g., this lets us store them efficiently in an array How does this work? y using trickle down (delete) and trickle up (insert) These use only a small number of steps (log n) for balancing So, we need something similar for STs! PS 223, rute orce pproach When inserting (or deleting): 1. Insert item into the ST normally 2. o an inorder traversal, save into a temporary array How are values ordered in the array? Remove each element from the ST as you go 3. Select elements in the array to insert back into the ST hoose elements such that the resulting ST is balanced How should we select the elements? Insert Inorder Traversal Output array PS 223, 2009 Rebuild Tree 10 5

6 rute orce pproach To rebuild the tree from a sorted list 1. Pick the middle element (this becomes the root) 2. Recursively build left subtree from array[0.. middle 1] 3. Recursively build right subtree from array[middle+1.. n] Insert Inorder Traversal Output array Rebuild Tree PS 223, rute orce pproach void RebuildTree(bstree & tree, item array[], int first, int last) { if(first <= last) { int middle = (first + last) / 2; tree.insert(array[middle]); RebuildTree(tree, array, first, middle 1); RebuildTree(tree, array, middle+1, last); Insert Inorder Traversal Output array Rebuild Tree PS 223,

7 rute orce pproach What is the cost? inding/retrieving an item becomes O(log n) Inorder traversal is O(n) Reinserting is O(nlog n) O(n) inserts each O(log n) So the total cost is O(log n + n + nlog n) = O(nlog n) isadvantages This is expensive (e.g., compared to a Heap) Uses O(n) extra space for temporary array We can do better than this! VL and Red lack (binary trees) 2-3, 2-3-4, Trees (for n-ary trees) PS 223, VL Trees [delson-velskii & Landis, 1962] Use tree rotations to rebalance the tree o tree rotations (if needed) after insert or delete our cases: Single rotation ( left-left ) Single rotation ( right-right ) ouble rotation ( left-right ) ouble rotation ( right-left ) Traverse up the tree from inserted/deleted node Only necessary if an insertion/deletion changes the balance Store a balance factor at each node PS 223,

8 VL Trees Single rotation example Insert b = b = Single Rotabon PS 223, VL Trees General case for single rotation ( left-left ) Insertion in left subtree of left child of (subtree ) Tree balanced before insertion nd becomes unbalanced after insertion Single rota1on (le3 le3 case) b = 0 The rotabon sets the subtree to its original height! b = 0 PS 223,

9 VL Trees We are done with insert after the rotation The rotation sets the subtree (now rooted at ) to its original balanced height So no more rotations needed! Single rota1on (le3 le3 case) b = 0 The rotabon sets the subtree to its original height! b = 0 PS 223, VL Trees General case for single rotation ( right-right ) Insertion in right subtree of right child of (subtree ) This is just the mirror image of the left-left case Single rota1on (right right case) b = -2 The rotabon sets the subtree to its original height! b = -1 PS 223,

10 VL Trees // given k2, return root of the single rotated subtree node * RotateWithLe2hild(node * k2) { // given k1, return root of the single rotated subtree node * RotateWithRighthild(node * k1) { PS 223, VL Trees // given k2, return root of the single rotated subtree node * RotateWithLe2hild(node * k2) { node * k1 = k2 >lemhild; k2 >lemhild = k1 >righthild; k1 >righthild = k2; return k1; PS 223,

11 VL Trees // given k1, return root of the single rotated subtree node * RotateWithRighthild(node * k1) { node * k2 = k1 >righthild; k1 >righthild = k2 >lemhild; k2 >lemhild = k1; return k2; PS 223, VL Trees Unfortunately, sometimes a single rotation does not rebalance the tree Single rota1on (le3 le3 case) b = -2 b = -1 Oops this (lem lem) rotabon didn t help!!! This is because we inserted into the right subtree of the le3 node PS 223,

12 VL Trees We sometimes need 2 rotations General case for double rotation (left-right) k 3 ouble rota1on (le3 right case) k 3 or 0 irst rota1on b = -1 or 0 One of these has the inserted node PS 223, VL Trees General case for double rotation (left-right) continued k 3 ouble rota1on (le3 right case) or 0 Second rota1on k 3 or 0 PS 223,

13 VL Trees ouble Rotation ( left-right ) // given k3, return root of the single rotated subtree node * oublerotatewithle2hild(node * k3) { k3 >lemhild = RotateWithRighthild(k3 >lemhild); return RotateWithLe2hild(k3); PS 223, VL Trees ouble Rotation ( right-left ) // given k1, return root of the single rotated subtree node * oublerotatewithrighthild(node * k1) { k1 >righthild = RotateWithLe2hild(k1 >righthild); return RotateWithRighthild(k1); PS 223,

14 VL Trees Notes on traversal ost The cost for a single or double rotation is O(1) The total cost is O(log n) since we have to traverse the tree along a path from leaf to root ut insertion/deletion still remains O(log n)! ompare this to O(nlog n) in our brute force approach or insertions Once we rebalance a subtree, we are done no need to continue rebalancing (be sure you know why!) This is not always the case for deletions PS 223, VL Trees Notes on traversal Unlike insertions, for deletions we sometimes have to keep traversing up the after a rotation Note that this doesn t change the O(log n) deletion time r elete r Single Rota1on (right right) r b = -2!!! d s s b = -1 s PS 223,

15 omments on VL Trees VL vs other approaches Rotations and traversals are hard to get right ut more importantly, the traversals create overhead Red lack tree is an alternative self-balancing approach In practice, faster insertion and deletion Slower retrieval time We will talk about Red lack trees on Thursday ssignment 7 asks you to extend your bstree class to be a Red lack binary search tree and use this in your dictionary class PS 223, or next time Reading h. 12: Upcoming due dates ssignment 6 due Thursday Project Part 2 New assignment next Thursday PS 223,