CS2012 Programming Techniques II

Size: px

Start display at page:

Download "CS2012 Programming Techniques II"

Edmund Malone
5 years ago
Views:

1 14/02/2014 C2012 Programming Techniques II Vasileios Koutavas Lecture 14 1

2 BTs ordered operations deletion 27

3 T implementations: summary implementation guarantee average case search insert delete search hit insert delete ordered iteration? operations on keys sequential search (linked list) N N N N/2 N N/2 no equals() binary search (ordered array) lg N N N lg N N/2 N/2 yes compareto() BT N N N 1.39 lg N 1.39 lg N??? yes compareto() Next. Deletion in BTs. 28

4 BT deletion: lazy approach To remove a node with a given key: et its value to null. Leave key in tree to guide searches (but don't consider it equal to search key). delete I C I C tombstone N N Cost. ~ 2 ln N' per insert, search, and delete (if keys in random order), where N' is the number of key-value pairs ever inserted in the BT. Unsatisfactory solution. Tombstone overload. 29

Deleting the minimum To delete the minimum key: Go left until finding a node with a null left link. eplace that node by its right link. Update subtree counts.

5 Deleting the minimum To delete the minimum key: Go left until finding a node with a null left link. eplace that node by its right link. Update subtree counts. go left until reaching null left link C public void deletein() { root = deletein(root); return that node s right link C available for garbage collection private Node deletein(node x) { if (x.left == null) return x.right; x.left = deletein(x.left); x.n = 1 + size(x.left) + size(x.right); return x; update links and node counts after recursive calls C

6 BTree delete final.java Page 1 class TreeNode<Key extends Comparable<Key>, Value> { Key key; Value value; TreeNode<Key,Value> left, right; int size; public TreeNode(Key key, Value value) { this.key = key; this.value = value; this.size = 1; this.left = this.right = null; public class BTree<Key extends Comparable<Key>, Value> { TreeNode<Key,Value> _root; //... // // delete methods // /** * Public deletein method exposed to clients. **/ public void deletein() { _root = deleteinfromtreewithoot(_root); /** * Deletes the minimum element in the subtree with root rootnode. * rootnode : the root of the current subtree */ private TreeNode<Key,Value> deleteinfromtreewithoot(treenode<key,value> rootnode ) { if (rootnode == null) return null; if (rootnode.left == null) { //base case: we reached the min key > return the right child as the //new root of this subtree return rootnode.right; else { //the min key is in the left subtree rootnode.left = deleteinfromtreewithoot(rootnode.left); rootnode.size = 1 + getizeoftreewithoot(rootnode.left) + getizeoftreewithoot(rootnode.right); return rootnode;

7 ibbard deletion To delete a node with key k: search for node t containing key k. Case 0. [0 children] Delete t by setting parent link to null. deleting C C node to delete replace with null link C available for garbage collection update counts after recursive calls

8 ibbard deletion To delete a node with key k: search for node t containing key k. Case 1. [1 child] Delete t by replacing parent link. deleting update counts after recursive calls C C C node to delete replace with child link available for garbage collection

9 ibbard deletion To delete a node with key k: search for node t containing key k. Case 2. [2 children] Find successor x of t. Delete the minimum in t's right subtree. Put x in t's spot. x has no left child but don't garbage collect x still a BT node to delete C t C go right, then go left until reaching null left link x search for key successor min(t.right) reaching null left link t.left x C C 5 deletein(t.right) 7 update links and node counts after recursive calls 33

10 BTree delete final.java Page 2 /** * Public delete method exposed to clients; it deletes the node containing the * searchkey. searchkey : the key to delete **/ public void delete(key searchkey) { _root = deletefromtreewithoot(_root, searchkey); /** * Private, recursive delete method. * rootnode : the root of the current subtree in which we will perform the * deletion searchkey : the key to delete the new root of the subtree **/ private TreeNode<Key,Value> deletefromtreewithoot(treenode<key,value> rootnode, Key searchkey) { if (rootnode == null) { // empty tree > searchkey is not in the empty tree return null; else { // the tree is not empty > searchkey may be in the root node, the left //subtree, or the right subtree. int cmp = searchkey.compareto(rootnode.key); if (cmp < 0) { // searchkey < rootnode.key > delete in the left subtree rootnode.left = deletefromtreewithoot(rootnode.left, searchkey); else if (cmp > 0) { // searchkey > rootnode.key > delete in the right subtree rootnode.right = deletefromtreewithoot(rootnode.right, searchkey); else //if (cmp == 0) { // searchkey == rootnode.key > we have found the searchkey in the rootnode if (rootnode.right == null) { return rootnode.left; else { // find and delete the min of the right subtree TreeNode<Key,Value> rightin = getinnodefromtreewithoot(rootnode.right); rootnode.right = deleteinfromtreewithoot(rootnode.right); //replace rootnode with min rightin.left = rootnode.left; rightin.right = rootnode.right; rootnode = rightin; // update size before returning rootnode.size = 1 + getizeoftreewithoot(rootnode.left) + getizeoftreewithoot(rootnode.right); return rootnode;

ibbard deletion: Java implementation public void delete(key key) { root = delete(root, key); private Node delete(node x, Key key) { if (x == null) return null; int cmp = key.compareto(x.

11 ibbard deletion: Java implementation public void delete(key key) { root = delete(root, key); private Node delete(node x, Key key) { if (x == null) return null; int cmp = key.compareto(x.key); if (cmp < 0) x.left = delete(x.left, key); else if (cmp > 0) x.right = delete(x.right, key); else { if (x.right == null) return x.left; search for key no right child Node t = x; x = min(t.right); x.right = deletein(t.right); x.left = t.left; x.n = size(x.left) + size(x.right) + 1; return x; replace with successor update subtree counts 34

12 ibbard deletion: analysis Unsatisfactory solution. Not symmetric. urprising consequence. Trees not random (!) sqrt (N) per op. Longstanding open problem. imple and efficient delete for BTs. 35

13 T implementations: summary implementation guarantee average case search insert delete search hit insert delete ordered iteration? operations on keys sequential search (linked list) N N N N/2 N N/2 no equals() binary search (ordered array) lg N N N lg N N/2 N/2 yes compareto() BT N N N 1.39 lg N 1.39 lg N N yes compareto() other operations also become N if deletions allowed ed-black BT. Guarantee logarithmic performance for all operations. 36

14 3.3 BLNCD C T lgorithms 2-3 search trees red-black BTs B-trees (optional) OBT DGWICK KVIN WYN

15 2-3 tree llow 1 or 2 keys per node. 2-node: one key, two children. 3-node: two keys, three children. ymmetric order. Inorder traversal yields keys in ascending order. Perfect balance. very path from root to null link has same length. 3-node 2-node ow??? ll shall be revealed. smaller than J larger than J L P between and J null link 13

16 2-3 tree demo earch. Compare search key against keys in node. Find interval containing search key. Follow associated link (recursively). search for J L P 14

17 2-3 Trees Insert (into 2-node) is bigger than, and.right is null. joins. Important: Never create new nodes at the bottom! 15

18 2-3 Trees Insert (into 3-node) joins. [VIOLTION] 4 node created. end to its parent. Create two new 2-nodes from the debris. Important: Other than empty tree, only way to make new nodes. 16

19 2-3 Trees P L L P Insert L (into 3-node with 3-node parent) [VIOLTION] LP created. 17

20 2-3 Trees L P L P Insert L (into 3-node with 3-node parent) [VIOLTION] LP created. end L up, create and P. [VIOLTION] L created. 18

21 2-3 Trees L P L P Insert L (into 3-node with 3-node parent) [VIOLTION] LP created. end L up, create and P. [VIOLTION] L created. end L to join parent (no parent, so new root) Create two new 2-nodes - from the debris. L ach gets custody of two nodes. P Important: Only way to increase tree height is by splitting the root. 19

22 2-3 tree construction demo insert 20

23 2-3 tree construction demo 2-3 tree L P 21

Lecture 14: Binary Search Trees (2)

Lecture 14: Binary Search Trees (2) cs2010: algorithms and data structures Lecture 14: Binary earch Trees (2) Vasileios Koutavas chool of omputer cience and tatistics Trinity ollege Dublin lgorithms OBT DGWIK KVIN WYN 3.2 BINY T lgorithms