 Download Download Presentation Binary Search Tree

# Binary Search Tree

Download Presentation ## Binary Search Tree

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Binary Search Tree • A kind of binary tree • Each node stores an item • For every node X, all items in its left subtree are smaller than X and all items in its right subtree are larger than X 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

2. 6 2 8 1 4 3 Binary Search Tree 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

3. 2 8 3 6 1 4 Algorithms for Binary Search Tree • Most algorithms for binary search trees use recursive function. • Recursively apply the same function on either left or right subtree, depending on the value stored in the root. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

4. find 3 6 1 4 8 3 2 < > < Binary Search Tree: Find Recursively finds the node that contain X in either left or right subtree. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

5. 2 2 8 8 3 3 6 6 1 4 4 1 5 Binary Search Tree: Insert insert 5 Recursively inserts X into either left or right subtree. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

6. 2 2 8 8 3 3 6 6 1 1 4 4 Delete (with one child) delete 4 Recursively delete X from either left or right subtree. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

7. 2 3 8 8 4 4 3 3 6 6 1 1 5 5 Delete (with two children) delete 2 delete (3) Replace data of the node (2) with the smallest data of its right subtree (3) and delete that node (3) from the right subtree 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

8. Comparable Interface • Read section 1.4.3 and B.2.3 • Searching and sorting algorithms work on Objects that can be compared to each other. In other words, these Objects must have some method for comparing. • An interface declares a set of methods that a class that implements the interface must have. • Comparable interface declares compareTo( ) method. • Searching and sorting algorithms work on any Objects that implement Comparable interface. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

9. compareTo( ) • int compareTo( Object rhs ) returns negative if this Object is less than rsh, zero if they are equal, and positive if this Object is greater than rhs • String and wrapper classes such as Integer all implement Comparable interface and therefore have compareTo( ) method. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

10. public interface Comparable { int compareTo( Comparable rhs ); } public class MyInterger implements Comparable { public int compareTo( Comparable rhs ) { return value < ((MyInteger)rhs).value ? -1 : value == ((MyInteger)rhs).value ? 0 : 1; } ... ... } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

11. Binary Search Tree class BinaryNode { // Constructors BinaryNode( Comparable theElement ) { this( theElement, null, null ); } BinaryNode( Comparable theElement, BinaryNode lt, BinaryNode rt ) { element = theElement; left = lt; right = rt; } // Friendly data; accessible by other package routines Comparable element; // The data in the node BinaryNode left; // Left child BinaryNode right; // Right child } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

12. public class BinarySearchTree { public BinarySearchTree( ) { root = null; } public void insert( Comparable x ) public void remove( Comparable x ) public Comparable findMin( ) public Comparable findMax( ) public Comparable find( Comparable x ) public void makeEmpty( ) public boolean isEmpty( ) public void printTree( ) private Comparable elementAt( BinaryNode t ) private BinaryNode insert( Comparable x, BinaryNode t ) private BinaryNode remove( Comparable x, BinaryNode t ) private BinaryNode findMin( BinaryNode t ) private BinaryNode findMax( BinaryNode t ) private BinaryNode find( Comparable x, BinaryNode t ) private void printTree( BinaryNode t ) private BinaryNode root; } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

13. public static void main( String [ ] args ) { final int NUMS = 4000; BinarySearchTree t = new BinarySearchTree( ); for( int i = 1; i < NUMS; i++ ) t.insert( new MyInteger( i ) ); for( int i = 1; i < NUMS; i+= 2 ) t.remove( new MyInteger( i ) ); if( NUMS < 40 ) t.printTree( ); if( ((MyInteger)(t.findMin( ))).intValue( ) != 2 || ((MyInteger)(t.findMax( ))).intValue( ) != NUMS - 2 ) System.out.println( "FindMin or FindMax error!" ); } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

14. public void printTree( ) { if( isEmpty( ) ) System.out.println( "Empty tree" ); else printTree( root ); } private void printTree( BinaryNode t ) { if( t != null ) { printTree( t.left ); System.out.println( t.element ); printTree( t.right ); } } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

15. public Comparable find( Comparable x ) { return elementAt( find( x, root ) ); } private BinaryNode find( Comparable x, BinaryNode t ) { /* find() recursively finds the node that contain x in either left or right subtree and returns a reference to that node, and returns null if not found */ if( t == null ) return null; if( x.compareTo( t.element ) < 0 ) return find( x, t.left ); else if( x.compareTo( t.element ) > 0 ) return find( x, t.right ); else return t; // Match } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

16. public Comparable findMin( ) { return elementAt( findMin( root ) ); } private BinaryNode findMin( BinaryNode t ) { /* Find the left-most leaf node */ if( t == null ) return null; else if( t.left == null ) return t; return findMin( t.left ); } /* Nonrecursive implementation private BinaryNode findMin( BinaryNode t ) { if( t != null ) while ( t.left != null ) t = t.left; return t; } */ 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

17. public Comparable findMax( ) { return elementAt( findMax( root ) ); } private BinaryNode findMax( BinaryNode t ) { /* Find the right-most leaf node */ if( t == null ) return null; else if( t.right == null ) return t; return findMax( t.right ); } /* Nonrecursive implementation private BinaryNode findMax( BinaryNode t ) { if( t != null ) while( t.right != null ) t = t.right; return t; } */ 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

18. public void insert( Comparable x ) { root = insert( x, root ); } private BinaryNode insert( Comparable x, BinaryNode t ) /* insert() recursively inserts data into either left or right subtree and returns a reference to the root of the new tree */ { /* 1*/ if( t == null ) /* 2*/ t = new BinaryNode( x, null, null ); /* 3*/ else if( x.compareTo( t.element ) < 0 ) /* 4*/ t.left = insert( x, t.left ); /* 5*/ else if( x.compareTo( t.element ) > 0 ) /* 6*/ t.right = insert( x, t.right ); /* 7*/ else /* 8*/ ; // Duplicate; do nothing /* 9*/ return t; } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

19. public void remove( Comparable x ) { root = remove( x, root ); } private BinaryNode remove( Comparable x, BinaryNode t ) { /* remove() recursively removes data from either left or right subtree and returns a reference to the root of the new tree */ if( t == null ) return t; // Item not found; do nothing if( x.compareTo( t.element ) < 0 ) t.left = remove( x, t.left ); else if( x.compareTo( t.element ) > 0 ) t.right = remove( x, t.right ); else if( t.left != null && t.right != null ) /* Two children. Replace data of this node with the smallest data of the right subtree and delete that node from the right subtree. */ { t.element = findMin( t.right ).element; t.right = remove( t.element, t.right ); } else t = ( t.left != null ) ? t.left : t.right; return t; } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

20. Lazy Deletion • When an element is to be deleted, it is left in the tree and marked as being deleted. • If there are duplicate items, the variable that keeps the number of duplicated items is just decremented. • If a deleted item is reinserted, no need to allocate new node. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

21. Shape, Height, and Size • Given height, balanced tree hold maximum number of nodes • Given number of nodes, balanced tree is the shortest • When height increases by one, number of nodes in balanced tree approximately doubles. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

22. Average-Case • Balanced binary tree: height = log(n+1) - 1 • Average binary tree: height = O(log N) • After lots of insert/remove operations, binary search tree becomes imbalance (remove operation make the left subtree deeper than the right) • If insert presorted data into binary search tree, the tree will have only nodes with right child. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

23. Balance Binary Search Trees First attempt: Left and right subtree must have the same height Second attempt: Every node must have left and right subtrees of the same height 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

24. AVL Tree • AVL Tree = Adelson-Velskii and Landis Tree • A binary search tree with balance condition • Self-adjusting to maintain balance condition • Ensure that the depth of the tree is O(log N) 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

25. AVL Tree • For every node, the height of the left and right subtrees can differ by at most 1 • Height information is kept for each node • Height is at most 1.44log(N+2) - .328 or slightly more than logN 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

26. 8 12 4 2 6 10 5 An AVL Tree Not an AVL Tree 8 12 4 2 6 5 7 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

27. Smallest AVL Tree of Height 5 Minimum number of nodes in an AVL tree of height h is S(h) = S(h-1)+S(h-2)+1, S(0)=1, S(1) = 2 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

28. Violation of the AVL Property • Inserting a node could violate the AVL property if it cause a height imbalance (two subtrees’ height differ by two) • Solution: The deepest node with imbalanced subtrees must be rebalanced 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

29. 8 12 4 2 6 5 Insertion Causes Imbalance 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

30. 8 8 12 12 4 4 10 14 2 6 15 1 Four Cases of Violation Insert into left subtree of the left child Insert into right subtree of the right child 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

31. 8 8 12 12 4 4 10 14 2 6 11 5 Four Cases of Violation Insert into right subtree of the left child Insert into left subtree of the right child 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

32. 2 1 2 3 6 5 6 7 4 4 4 4 Four Cases of Violation 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

33. 4 8 12 8 12 4 2 6 2 6 1 1 Single Rotation k1 After Before k2 k1 k2 Z Y X Y Z X Insertion of 1 causes X to be one level deeper than Y and two level deeper than Z. The violation occurs at k2. The rotation maintains k1 < Y < k2. X is lifted up one level, Y remains at the same level, and Z is lowered down one level. The new height is the same as before the insertion. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

34. 8 12 12 4 8 4 10 14 10 14 15 15 Single Rotation Before After 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

35. 8 4 12 4 2 8 2 6 6 12 5 5 Single Rotation (this one does not work) Before After Z X X Z Y Y Y remains at the same level, so it does not work. 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

36. k3 k2 Z k3 k1 k1 X k2 Y1 Y2 X Y1 Y2 Z Double Rotation Before After double rotation An insertion into Y1 or Y2 causes violation at k3. k1 < Y1 < k2 < Y2 < k3 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

37. 8 12 6 4 6 2 5 5 Double Rotation After first rotation Before 8 12 4 2 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

38. 6 8 8 4 12 6 4 12 2 2 5 5 Double Rotation After first rotation After second rotation 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

39. 8 12 4 8 10 14 10 4 11 12 14 11 Double Rotation After first rotation Before 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

40. 10 8 8 4 10 4 12 12 14 14 11 11 Double Rotation After first rotation After second rotation 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

41. class AvlNode { Comparable element; AvlNode left; AvlNode right; int height; AvlNode( Comparable theElement ) { this( theElement, null, null ); } AvlNode( Comparable theElement, AvlNode lt, AvlNode rt ) { element = theElement; left = lt; right = rt; height = 0; } } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

42. private AvlNode insert( Comparable x, AvlNode t ) { if( t == null ) t = new AvlNode( x, null, null ); else if( x.compareTo( t.element ) < 0 ) { /* insert into the left subtree */ t.left = insert( x, t.left ); if(height( t.left ) - height( t.right ) == 2 ) if( x.compareTo( t.left.element ) < 0 ) t = rotateWithLeftChild( t ); else t = doubleWithLeftChild( t ); } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

43. else if( x.compareTo( t.element ) > 0 ) { /* insert into the right subtree */ t.right = insert( x, t.right ); if( height( t.right ) - height( t.left ) == 2 ) if( x.compareTo( t.right.element ) > 0 ) t = roteWithRightChild( t ); else t = doubleWithRightChild( t ); } else ; t.height = max( height( t.left ), height( t.right ) ) + 1; return t; } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University

44. private static AvlNode rotateWithLeftChild( AvlNode k2 ) { AvlNode k1 = k2.left; k2.left = k1.right; k1.right = k2; k2.height = max( height( k2.left ), height( k2.right ) ) + 1; k1.height = max( height( k1.left ), k2.height ) + 1; return k1; } private static AvlNode doubleWithLeftChild( AvlNode k3 ) { k3.left = rotateWithRightChild( k3.left ); return rotateWithLeftChild( k3 ); } 2110211 Intro. to Data Structures Chapter 4 Tree Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University