Binary search trees

What’s on the menu? ADT DictionaryBST & Algorithms SimulatorComplexity

Abstract Data Type: Dictionary We’ve seen two ADTs, or behaviours. ListStack add(Object o) get(int i) remove(int i) push(Object o) peek() pop() Let’s look at a 3rd ADT. Dictionary Binary Search Trees

Abstract Data Type: Dictionary We’ve seen two ADTs, or behaviours.Let’s look at a 3rd ADT. Dictionary What’s a dictionary? A set of keys, each associated with a value. key value Binary Search Trees

Abstract Data Type: Dictionary public interface Dictionary{ void add(int key, Object value); void reassign(int key, Object value); Object remove(int key); Object lookup(int key); } Binary Search Trees add a new key associated with a value change the value associated with the key remove the key (hence the value) and return the value return the value associated with the key

Binary Search Trees Abstract Data Type: Dictionary public void example(Dictionary D){ D.add(3, « cheers »); D.add(5, « salamati »); System.out.println( _____D.lookup(5)); D.reassign(5, « slàinte »); System.out.println( _____D.lookup(5)); D.remove(3); } Dictionary D {3, cheers} {5, salamati}{5, slàinte} > salamati > slàinte

Binary Search Trees An implementation: Binary Search Tree A binary search tree (BST) is a tree in which a node can have at most two children and the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller Not a BST: 6 is greater than 4 (and 5) ! In representation, we usually only show the keys. Remember that they are binded to a value.

Binary Search Trees Algorithm: add(int key, Object data) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller add(9, « blabla »); 9 < 12 9 > 8 9 < add(14, « blabla »); 14 > < 16 14

Binary Search Trees Algorithm: add(int key, Object data) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller. private void add(Node current, int key, Object data){ if(key>current.getKey()){ if(current.getRightChild()==null){ Node n = new Node(key, data); current.setRightChild(n); }else add(current.getRightChild(),key, data); }else{ if(current.getLeftChild()==null){ Node n = new Node(key, data); current.setLeftChild(n); }else add(current.getLeftChild(),key, data); } the key I want to add is higher than the current one, I go in the right subtree no right subtree? Then I make a Node and I’m done. otherwise, go deeper in the tree similarly, if the key is less or equal then go in the left subtree

Binary Search Trees Algorithm: add(int key, Object data) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller. private void add(Node current, int key, Object data){ if(key>current.getKey()){ if(current.getRightChild()==null){ Node n = new Node(key, data); current.setRightChild(n); }else add(current.getRightChild(),key, data); }else{ if(current.getLeftChild()==null){ Node n = new Node(key, data); current.setLeftChild(n); }else add(current.getLeftChild(),key, data); } public void add(int key, Object data){ if(root==null) root = new Node(key,data); else add(root,key,data); } In purple, the general case. In blue, when we stop. Below, how we start. The algorithm that the user calls is public. The ‘real’ one private.

Binary Search Trees Algorithm: lookup(int key) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller. Write the algorithm that returns the data bound to a key. Steps you should be thinking of: what do I do in the general case? when do I stop? how do I start? Functions: getRightChild()getLeftChild() getKey() getdata() If the key is greater than the current, go in the right subtree; otherwise, go left. No node: null. Found the key: return the data. No root: null. Otherwise, start on the root.

Binary Search Trees Algorithm: lookup(int key) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller. public Object lookup(int key){ if(root==null) return null; return getNode(root, key); } private Object getNode(Node current, int key){ if(current==null) return null; if(current.getKey()==key) return current.getData(); if(key>current.getKey()) return getNode(current.getRightChild(), key); return getNode(current.getLeftChild(), key); } start general stop

Binary Search Trees Algorithm: lookup(int key) The Rule: the keys into the right subtree of a node c are all greater than the key of c, while the keys in the left subtree are all smaller. public Object lookup(int key){ if(root==null) return null; return getNode(root, key); } private Object getNode(Node current, int key){ if(current==null) return null; if(current.getKey()==key) return current.getData(); if(key>current.getKey()) return getNode(current.getRightChild(), key); return getNode(current.getLeftChild(), key); } 9 1 lookup(5); > null lookup(1);

Binary Search Trees Algorithm: findMin(Node current) Starting from a given node, return the node with the smallest key Strategy: go in the left subtree as long as you can. If you follow the algorithm, it always goes forward in only one direction, like a LinkedList. So it’s not truly recursive, and it can be written in an iterative fashion.

Binary Search Trees Algorithm: findMin(Node current) Starting from a given node, return the node with the smallest key. Strategy: go in the left subtree as long as you can. private Node findMin( Node t ) { if( t != null ) while( t.getLeftChild() != null) t = t.getLeftChild(); return t; }

Binary Search Trees Algorithm: remove(int key) Case 0: You are removing a node with 0 children (i.e. a leaf). stolen from John Edgar Example: removing 30. Strategy: go to the parent (here 23), and set the node to null.

Binary Search Trees Algorithm: remove(int key) Case 1: You are removing a node with only one child. stolen from John Edgar Example: removing 79. Strategy: go to the parent (here 63), and replace the node by its subtree

Binary Search Trees Algorithm: remove(int key) Case 2: You are removing a node with two children. stolen from John Edgar Strategy: replace the node by the minimum in its right subtree temp If we want to remove 32, we need to replace it by one of its children.

Binary Search Trees protected Node remove(int key, Node current){ if(current==null) return null; if(key < current.getKey()) current.setLeftChild(remove(key, current.getLeftChild())); else if(key > current.getKey()) current.setRightChild(remove(key,current.getRightChild())); else if(current.getLeftChild() != null && current.getRightChild() != null ) { Node rightMin = findMin(current.getRightChild()); current.setData(rightMin.getData()); current.setKey(rightMin.getKey()); current.setRightChild(removeMin(current.getRightChild())); } else if(current.getLeftChild()==null) current = current.getRightChild(); else current = current.getLeftChild(); return current; } Algorithm: remove(int key) locate the node If there are 2 children then replace by the minimum in the right subtree, and delete this minimum. 1 child: replace by the subtree 0 child: replace by the subtree (which is null…)

Binary Search Trees Complexity If I’m looking for something, how long can it take at most to find it? The size of the longest path (root to leaf) is the height h of the tree. Since I know exactly where I’m going, it takes me at most O(h). Add/Remove/Lookup are in O(h). If we’re lucky, the tree is well balanced: every level is full. Level 1: 1 node. Level 2: 2 nodes. Level 3: 4 nodes. Level 4: 8 nodes. Level n: 2^n nodes. h = log n 2

Binary Search Trees Complexity If I’m looking for something, how long can it take at most to find it? The size of the longest path (root to leaf) is the height h of the tree. Since I know exactly where I’m going, it takes me at most O(h). Add/Remove/Lookup are in O(h). If we’re lucky, the tree is well balanced: every level is full. h = log n If we’re unlucky, the tree is totally unbalanced, looking like a LinkedList: h = n.

Binary Search Trees Complexity Add/Remove/Lookup are in O(h). → Balanced tree: Add/Remove/Lookup are in O(log n) → Unbalanced tree: Add/Remove/Lookup are in O(n) It is important to keep the tree balanced in order to have the algorithms efficient. We will see different ways to achieve it. 2 If you’re simply asked about the complexity, say O(h). If you have to be more detailed, then distinguish balanced and unbalanced cases.