ch13 binary search tree
Embed Size (px)
DESCRIPTION
TRANSCRIPT
 1. Chapter 13 BinarySearch Trees
2. Chapter Objectives
 Define a binary search tree abstract data structure
 Demonstrate how a binary search tree can be used to solve problems
 Examine various binary search tree implementations
 Compare binary search tree implementations
3. Binary Search Trees
 A binary search tree is a binary tree with the added property that for each node, the left child is less than the parent is less than or equal to the right child
 Given this refinement of our earlier definition of a binary tree, we can now include additional operations
4. FIGURE 13.1 The operationson a binary search tree 5. Listing 13.1 6. Listing 13.1(cont.) 7. FIGURE 13.2 UML descriptionof the BinarySearchTreeADT 8. Implementing Binary Search Trees With Links
 We can simply extend our definition of a LinkedBinaryTree to create a LinkedBinarySearchTree
 This class will provide two constructors, one to create an empty tree and the other to create a oneelement binary tree
9. LinkedBinarySearchTree  Constructors 10. Implementing Binary Search Trees With Links
 Now that we know more about how this tree is to be used (and structured) it is possible to define a method to add an element to the tree
 The addElement method finds the proper location for the given element and adds it there as a leaf
11. LinkedBinarySearchTree  addElement 12. LinkedBinarySearchTree  addElement 13. LinkedBinarySearchTree  addElement 14. FIGURE 13.3 Adding elementsto a binary search tree 15. Removing Elements
 Removing elements from a binary search tree requires

 Finding the element to be removed

 If that element is not a leaf, then replace it with its inorder successor

 Return the removed element
16. Removing Elements
 The removeElement method makes use of a private replacement method to find the proper element to replace a nonleaf element that is removed
17. LinkedBinarySearchTree  removeElement 18. LinkedBinarySearchTree  removeElement 19. LinkedBinarySearchTree  removeElement 20. LinkedBinarySearchTree  replacement 21. LinkedBinarySearchTree  replacement 22. FIGURE 13.4Removing elements from a binary tree 23. Removing All Occurrences
 The removeAllOccurrences method removes all occurrences of an element from the tree
 This method uses the removeElement method
 This method makes a distinction between the first call and successive calls to the removeElement method
24. LinkedBinarySearchTree  removeAllOccurrences 25. The removeMin Operation
 There are three cases for the location of the minimum element in a binary search tree:

 If the root has no left child, then the root is the minimum element and the right child of the root becomes the new root

 If the leftmost node of the tree is a leaf, then we set its parents left child reference to null

 If the leftmost node of the tree is an internal node, then we set its parents left child reference to point to the right child of the node to be removed
26. FIGURE 13.5 Removing the minimum element from a binary search tree 27. Using Binary Search Trees:Implementing Ordered Lists
 Lets look at an example using a binary search tree to provide an efficient implementation of an ordered list
 For simplicity, we will implement both the ListADT and the OrderedListADT in the BinarySearchTreeList class
28. FIGURE 13.6 The common operations on a list 29. FIGURE 13.7 The operation particular to an ordered list 30. Listing 13.2 31. Listing 13.2(cont.) 32. Listing 13.2(cont.) 33. Listing 13.2(cont.) 34. FIGURE 13.8 Analysis of linked list and binary search tree implementations of an ordered list 35. Balanced Binary Search Trees
 Why is our balance assumption so important?
 Lets look at what happens if we insert the following numbers in order without rebalancing the tree:


 359121820

36. FIGURE 13.9 A degenerate binary tree 37. Degenerate Binary Trees
 The resulting tree is called a degenerate binary tree
 Degenerate binary search trees are far less efficient than balanced binary search trees (O(n) on find as opposed to O(logn))
38. Balancing Binary Trees
 There are many approaches to balancing binary trees
 One method is brute force

 Write an inorder traversal to a file

 Use a recursive binary search of the file to rebuild the tree
39. Balancing Binary Trees
 Better solutions involve algorithms such as redblack trees and AVL trees that persistently maintain the balance of the tree
 Most all of these algorithms make use of rotations to balance the tree
 Lets examine each of the possible rotations
40. Right Rotation
 Right rotation will solve an imbalance if it is caused by a long path in the left subtree of the left child of the root
41. FIGURE 13.10 Unbalanced tree and balanced tree after a right rotation 42. Left Rotation
 Left rotation will solve an imbalance if it is caused by a long path in the right subtree of the right child of the root
43. FIGURE 13.11 Unbalanced tree and balanced tree after a left rotation 44. Rightleft Rotation
 Rightleft rotation will solve an imbalance if it is caused by a long path in the left subtree of the right child of the root
 Perform a right rotation of the left child of the right child of the root around the right child of the root, and then perform a left rotation of the resulting right child of the root around the root
45. FIGURE 13.12 A rightleft rotation 46. Leftright Rotation
 Leftright rotation will solve an imbalance if it is caused by a long path in the right subtree of the left child of the root
 Perform a left rotation of the right child of the left child of the root around the left child of the root, and then perform a right rotation of the resulting left child of the root around the root
47. FIGURE 13.13 A leftright rotation 48. AVL Trees
 AVL trees keep track of the difference in height between the right and left subtrees for each node
 This difference is called the balance factor
 If the balance factor of any node is less than 1 or greater than 1, then that subtree needs to be rebalanced
 The balance factor of anynode can only be changed through either insertion or deletion of nodes in the tree
49. AVL Trees
 If the balance factor of a node is 2, this means the left subtree has a path that is too long
 If the balance factor of the left child is 1, this means that the long path is the left subtree of the left child
 In this case, a simple right rotation of the left child around the original node will solve the imbalance
50. FIGURE 13.14 A right rotation in an AVL tree 51. AVL Trees
 If the balance factor of a node is +2, this means the right subtree has a path that is too long
 Then if the balance factor of the right child is +1, this means that the long path is the right subtree of the right child
 In this case, a simple left rotation of the right child around the original node will solve the imbalance
52. AVL Trees
 If the balance factor of a node is +2, this means the right subtree has a path that is too long
 Then if the balance factor of the right child is 1, this means that the long path is the left subtree of the right child
 In this case, a rightleft double rotation will solve the imbalance
53. FIGURE 13.15 A rightleft rotation in an AVL tree 54. AVL Trees
 If the balance factor of a node is 2, this means the right subtree has a path that is too long
 Then if the balance factor of the left child is +1, this means that the long path is the right subtree of the left child
 In this case, a leftright double rotation will solve the imbalance
55. Red/Black Trees
 Red/Black trees provide another alternative implementation of balanced binary search trees
 A red/black tree is a balanced binary search tree where each node stores a color (usually implemented as a boolean)
 The following rules govern the color of a node:

 The root is black

 All children of a red node are black

 Every path from the root to a leaf contains the same number of black nodes
56. FIGURE 13.16 Valid red/black trees 57. Insertion into Red/Black Trees
 The color of a new element is set to red
 Once the new element has been inserted, the tree is rebalanced/recolored as needed to to maintain the properties of a red/black tree
 This process is iterative beginning at the point of insertion and working up the tree toward the root
 The process terminates when we reach the root or when the parent of the current element is black
58. Insertion into Red/Black Trees
 In each iteration of the rebalancing process, we will focus on the color of the sibling of the parent of the current node
 There are two possibilities for the parent of the current node:

 The parent could be a left child

 The parent could be a right child
 The color of a null node is considered to be black
59. Insertion into Red/Black Trees
 In the case where the parent of the current node is a right child, there are two cases

 Leftaunt.color == red

 Leftaunt.color == black
 If leftaunt.color is red then the processing steps are:
60. FIGURE 13.17 Red/black tree after insertion 61. Insertion into Red/Black Trees
 If leftaunt.color is black, we first must check to see if current is a left child or a right child
 If current is is a left child, then we must set current equal to current.parent and then rotate current.left to the right
 The we continue as if current were a right child to begin with:
62. Insertion into Red/Black Trees
 In the case where the parent of current is a left child, there are two cases:either rightuncle.color == red or rightuncle.color == black
 If rightuncle.color == red then the processing steps are:
63. FIGURE 13.18 Red/black tree after insertion 64. Insertion into Red/Black Trees
 If rightuncle.color == black then we first need to check to see if current is a left or right child
 If current is a right child then we set current equal to current.parent then rotate current.right ot the left around current
 We then continue as if current was left child to begin with:
65. Element Removal from Red/Black Trees
 As with insertion, the tree will need to be rebalanced/recolored after the removal of an element
 Again, the process is an iterative one beginning at the point of removal and continuing up the tree toward the root
 This process terminates when we reach the root or when current.color == red
 Like insertion, the cases for removal are symmetrical depending upon whether current is a left or right chid
 In insertion, we focused on the color of the sibling of the parent
 In removal, we focus on the color of the sibling of current keeping in mind that a null node is considered to be black
66. Element Removal from Red/Black Trees
 We will only examine the cases where current is a right child, the other cases are easily derived
 If the siblings color is red then we begin with the following steps:
67. FIGURE 13.19 Red/black tree after removal 68. Element Removal from Red/Black Trees
 Next our processing continues regardless of whether the original sibling was red or black
 Now our processing is divided into two cases based upon the color of the children of the sibling
 If both of the children of the sibling are black then:
69. Element Removal from Red/Black Trees
 If the children of the sibling are not both black, then we check to see if the left child of the sibling is black
 If it is, then we must complete the following steps before continuing:
70. Element Removal from Red/Black Trees
 Then to complete the process in the case when both of the children of the sibling are not black:
71. Binary Search Trees in the Java Collections API
 Java provides two implementations of balanced binary search trees

 TreeSet

 TreeMap
 In order to understand the difference between these two, we must first discuss the difference between a set and a map
72. Sets and Maps
 In the terminology of the Java Collections API, all of the collections we have discussed thus far would be considered sets
 A set is a collection where all of the data associated with an object is stored in the collection
 A map is a collection where keys that reference an object are stored in the collection but the remaining data is stored separately
73. Sets and Maps
 Maps are useful because they allow us to manipulate keys within a collection rather than the entire object
 This allows collections to be smaller, more efficient, and easier to manage
 This also allows for the same object to be part of multiple collections by having keys in each
74. The TreeSet and TreeMap Classes
 Both the TreeSet and TreeMap classes are red/black tree implementations of a balanced binary search tree
 The operations on both are listed in the following tables
75. TABLE 13.1 Operations on a TreeSet 76. TABLE 13.2 Operations on a TreeMap