Motivation Computer Information Systems Storage Retrieval Updates. Binary Search Trees. OrderedStructures. Binary Search Tree

Transcription

1 Binary Search Trees CMPUT Lecture Department of Computing Science University of Alberta Revised 21-Mar-05 In this lecture we study an important data structure: Binary Search Tree (BST) Motivation Computer Information Systems Storage Retrieval Updates Efficiency Search in a sorted list O(log n) Maintenance Sorting: O(n log n) Update: O( log n) 2 OrderedStructures 3 Binary Search Tree 4 We have two implementations of the OrderedStructure interface: OrderedVector and OrderedList. For OrderedVector The time for finding an element is O(log n) comparisons due to a binary search. The time for adding or removing an element is O(log n) comparisons to find it and O(n) assignments to move existing elements to the right of it. For OrderedList The time for finding an element is O(n) comparisons due to a sequential search. The time for adding or removing an element is O(n) comparisons to find it and O(1) assignments to fix links. We want to combine the advantage of a binary search with the advantage of just fixing a few links during adding and removal to obtain an implementation called a BinarySearchTree where: The time for finding an element is O(log n) comparisons due to a binary search. The time for adding or removing an element is O(log n) comparisons to find it and O(1) assignments to fix links. A binary search tree (BST) is a binary tree in which, for every node, the element in the node is greater than or equal to the all elements in the left subtree and less than or equal to all the elements in the right subtree. 5 6 Sort Order in Binary Search Trees Properties of Binary Search Trees Many different BSTs can be formed from the same set of elements. However, an inorder traversal always produces the elements in sorted order:,,,,,,. A binary tree such that Each node is used to store one key (element) Keys in the left subtree are less than or equal to that in the root Keys in the right subtree are greater than that in the root Search in O( log n) Assume it is balanced Update in O( log n) Assume it is balanced Problem How to maintain a balanced binary search tree 1

2 7 8 History and Development AVL tree 2-3 three Balanced binary search tree B-tree B+tree OrderedStructure Hierarchy Like the structure package we will add BinarySearchTree as another implementation of OrderedStructure. Store Collection OrderedStructure OrderedVector OrderedList BinarySearchTree 9 BST is a subclass of BinaryTree (1) Unlike the structure package our BST class will be a subclass of BinaryTree. BST will inherit all of BinaryTree s methods and instance variables, and the fact it implements the Collection and BinaryTree Interfaces. However, addition and removal of elements is different since they must maintain the BST property. We must therefore override them. We will also override contains to make it more efficient. BST is a subclass of BinaryTree (2) We also must add preconditions to the attach methods to ensure the defining property of a BST is maintained. All the elements in the new subtree must lie in a range defined by all the ancestor elements and the position in the tree. What range of elements are permitted in subtrees A and B? BST - State and Constructor public class BST extends BinaryTree implements collection { // no additional instance variables are required // the 0-argument constructor in BinaryTree is all we need, // so no constructor need be included here. The major methods public boolean contains (Object anobj) Search operation public void add( Object anobj) Search operation Pointer adjustment public Object remove(object anobj) Search operation Pointer adjustment public Iterator elements() Search operations 2

3 13 14 Searching for an Element in a BST The Location of an Element in a BST To implement contains(object), add(object) and remove(object) we must first search for the object we are looking for. In contains(object), we are done when we either find it or ensure it is not in the tree. In add(object), the search determines not only whether it is there or not, but the specific location where it belongs. We can use this information to add it. In remove(object), the search determines not only whether it is there or not, but the specific location where it is, since we need this information to remove it. We use a locate method that returns either the node that contains the element or the parent of the node where the element should be added as a new leaf: Compare the element to the root element. If they are equal return the current tree. If element > root then recursively search the right subtree. Otherwise, recursively search the left subtree. If the subtree to be searched is null, return the current tree. Search for :,,, return Search for 5 or 15:,,, return Search for 25:,,, return Search for 75:,, return BST locate [protected] BST - contains protected static BinaryTreeInterface locate ( BinaryTreeInterface t, Comparable anobject) { //pre: anobject is non-null, t is a Binary Search Tree // post: returns subtree of t (or t itself) in which anobject // is the root element; If anobject does not occur in t, // returns the subtree which should have anobject as its child. if (t.isempty()) return t ; int comparison = anobject.compareto(t.rootelement()) ; if ( (comparison==0) ((comparison<0) && (!t.hasleft())) ((comparison>0) && (!t.hasright())) ) return t ; if (comparison < 0) return locate(t.left(),anobject) ; else return locate(t.right(),anobject) ; public boolean contains(object anobject) { // pre: anobject is non-null // post: returns true iff the receiver contains anobject if (this.isempty()) return false ; BinaryTreeInterface lookhere = locate(this, (Comparable) anobject) ; return lookhere.rootelement().equals(anobject) ; Adding an Element to a BST An element is always added in a new leaf node. We start with a call to locate. There are two cases: The element is not already in the tree. Insert it as the appropriate child of the parent node returned from locate. The element is already in the tree. If the left subtree of that node is empty, insert it as the left child. Otherwise recursively insert it into the left subtree. Add 5: locate, insert left Add 15: locate, insert right Add 75: locate, insert right Add : locate, insert left Add : locate, recursively insert in left subtree 17 Alternate Strategy for Add The previous strategy always inserts duplicate elements in the left subtree. Alternately, we could always insert duplicate elements in the right subtree by recursively inserting in the right subtree. Add 5: locate, insert left Add 15: locate, insert right Add 75: locate, insert right Add : locate, recursively insert in right subtree Add : locate, recursively insert in right subtree 18 3

4 19 BST - add public void add(object anobject) { // pre: anobject is non-null // post: anobject is added to the receiver so it remains a BST if (isempty()) { rootelement = anobject ; return ; Comparable newelement = (Comparable) anobject ; BinaryTreeInterface tryhere = locate(this, newelement) ; int comparison = newelement.compareto(tryhere.rootelement()) ; boolean goleft = (comparison <= 0) ; if ( goleft && tryhere.hasleft() ) { // anobject is in the receiver in a node that already has a // left subtree. Recursively add anobject to the subtree. tryhere.left().add(anobject) ; else { BST newnode = new BST() ; newnode.rootelement = anobject ; newnode.attachparent(tryhere,goleft); Strategy for Removing an Element Find the element in the tree Three cases: 1. If the element is in a leaf, delete the leaf. 2. If the element is in a node with a parent and one subtree, link around the node connect its subtree to its parent. 3. Otherwise, find a suitable element beneath the node, delete the node containing that element, and replace the element by that element Easy Case #1: Removing a Leaf To remove : 1. Find the node containing. node with Easy Case #2: Parent and One Child To remove : 1. Find the node containing. node with 2. Delete the leaf. 2. Link around it Hard Case Which elements are suitable for replacing? 90 Hard Case - suitable replacement Which elements are suitable for replacing? Either: Largest value in left subtree Smallest value in right subtree Deleting these will always be one of the easy cases. Why? 90 4

5 25 26 Example: remove 1. Find the node containing. 2. Find a suitable replacement below that node. largest in left subtree 3. Delete the node with the replacement (in this example by linking around it). 4. Replace by the replacement. node node BST remove (easy cases) public Object remove(object anobject) { // pre: anobject is non-null // post: if the receiver contains an element equal to anobject // one such element is removed and returned. // Otherwise null is returned. if (isempty()) return null ; BinaryTreeInterface where = locate(this, (Comparable)anObject) ; Object returnvalue = where.rootelement() ; if (! anobject.equals(returnvalue)) return null ; if ((!where.hasleft()) && (!where.hasright()) ) { // LEAF where.clear() ; else if (where.hasparent() && // PARENT AND ONE CHILD ( (!where.hasright()) (!where.hasleft())) ) { linkaround(where) ; BST remove (hard case) BST linkaround [protected] else { // non-leaf with no parent, or two children Object replacementelement = null ; if (where.hasleft()) { replacementelement = removelargest(where.left()); else { replacementelement = removesmallest(where.right()); where.setroot( replacementelement ) ; return returnvalue ; protected static void linkaround(binarytreeinterface t) { // pre: t has a parent and has at most one non-empty subtree // post: t's non-empty subtree (if it has one) has been attached // to its parent in its place. t is empty. BinaryTreeInterface child = null ; BinaryTreeInterface parent = t.parent() ; boolean isleftchild = parent.left() == t ; t.detachfromparent() ; if (t.hasleft()) { child = t.left() ; if (t.hasright()) { child = t.right(); if (child!= null) { child.detachfromparent() ; child.attachparent(parent,isleftchild); t.clear() ; BST removelargest [protected] 29 Efficiency of Binary Search Trees protected static Object removelargest(binarytreeinterface t) { // pre: t either is empty or its largest element is in a // node that has a parent. // post: if t is not empty, removes t's largest element // and returns it. Otherwise returns null. if (t.isempty()) return null ; BinaryTreeInterface largest = t ; while (largest.hasright()) { largest = largest.right() ; Object returnvalue = largest.rootelement() ; linkaround(largest) ; return returnvalue ; removesmallest is similar Each of the time consuming operations is O(h), where h is the height of the tree. If the tree is fairly balanced, h = log n so the operations are O(log n) However, since many binary trees can be made from the same elements, we could be unlucky when we make our tree and have a tree with height h = n, which is essentially a linked list and the search time is O(n). What insertion orders cause problems? 5

6 31 32 Unbalanced Binary Search Trees 1 Look at a tree with insertion order:,,, : Unbalanced Binary Search Trees 2 Look at a tree with insertion order:,,, : Balanced Binary Search Trees Balancing Binary Search Trees Look at a tree with insertion order:,,,, : There are sophisticated algorithms for balancing binary search trees, but we won't cover them in this course. However, if your BST becomes unbalanced, here is a simple approach: Traverse your BST and put each element into an array. Create a new BST and insert the elements from the array into the new BST, in a random order. This approach can also be used as an efficient sort: Traverse your unsorted container (in any order), putting the elements into a BST. Traverse the BST (inorder) and put the elements back into the container. Since adding an element to a BST is O(log n) and there are n elements to add, the insertion part of the algorithm is O(n log n). Since the final inorder traversal is O(n), the total sort algorithm complexity is O(n log n) 6