Post on 21-Dec-2015
transcript
A Binary Search Tree Implementation
Chapter 17
2
Chapter Contents
Getting Started An Interface for the Binary
Search Tree Duplicate Entries Beginning the Class
Definition Searching and Retrieving Traversing Adding an Entry
Recursive Implementation Removing an Entry
Whose Node is a leaf
Whose Node Has One Child
Whose Node has Two Children
In the Root Efficiency of Operations
Importance of Balance Order in Which Nodes
Are Added Implementation of the ADT
Dictionary
3
Getting Started
A binary search tree is a binary tree Nodes contain Comparable objects
For each node in the tree The data in a node is greater than the data in the
node's left subtree The data in a node is less than the data in the
node's right subtree
4
Getting Started
A binary search tree of names.
5
An Interface for the Binary Search Tree
import java.util.Iterator;public interface SearchTreeInterface extends TreeInterface{ public boolean contains(Comparable entry);
public Comparable getEntry(Comparable entry);public Comparable add(Comparable newEntry);public Comparable remove(Comparable entry);public Iterator getInorderIterator();
} // end SearchTreeInterface
6
Duplicate Entries
A binary search tree with duplicate entries.
How about we add one more Jared to above tree?
If duplicates are allowed, place the
duplicate in the entry's right subtree.
If duplicates are allowed, place the
duplicate in the entry's right subtree.
7
Beginning the Class Definition
import java.util.Iterator;public class BinarySearchTree extends BinaryTree
implements SearchTreeInterface{ public BinarySearchTree()
{ super();} // end default constructorpublic BinarySearchTree(Comparable rootEntry){ super();
setRootNode(new BinaryNode(rootEntry));} // end constructor. . .
8
Searching and Retrieving
Like performing a binary search of an array For a binary array
Search one of two halves of the array For the binary search tree
You search one of two subtrees of the binary search tree
9
Searching and Retrieving
The recursive search algorithmAlgorithm bstSearch(binarySearchTree, desiredObject)// Searches a binary search tree for a given object.// Returns true if the object is found.if (binarySearchTree is empty)
return falseelse if (desiredObject == object in the root of binarySearchTree)
return trueelse if (desiredObject < object in the root of binarySearchTree)
return bstSearch(left subtree of binarySearchTree, desiredObject)else
return bstSearch(right subtree of binarySearchTree, desiredObject)
10
Traversing
The SearchTreeInterface provides the method getInorderIterator Returns an inorder iterator
Our class is a subclass of BinaryTree It inherits getInorderIterator This iterator traverses entries in ascending order Uses the entries' method compareTo
11
Adding an EntryEssential Operation to
build a tree. Need to retain the relationship among tree nodes.
Every addition to binary search tree adds a new leaf to the tree
(a) A binary search tree; (b) the same tree after
adding Chad.
Q: Try to add Miguel and then Nancy to (a). What about add Nancy and Miguel? Trees are the same or not?
12
Adding an Entry Recursively
Recursively adding Chad to smaller subtrees of a binary search tree … continued →
13
Adding an Entry Recursively
(ctd.) Recursively adding Chad to
smaller subtrees of a binary search tree.
14
Removing an Entry
The remove method must receive an entry to be matched in the tree If found, it is removed Otherwise the method returns null
Three cases The node has no children, it is a leaf (simplest
case) The node has one child The node has two children
15
Removing an Entry, Node a Leaf
(a) Two possible configurations of leaf node N; (b) the resulting two possible configurations after removing node N by setting the child reference
of P to null
16
Removing an Entry, Node Has One Child
(a) Four possible configurations of node N with one child; (b) resulting two possible configurations after removing node N.
We make C a child of P instead of N
17
Removing an Entry, Node Has Two Children
Two possible configurations of node N that has two children.
If we remove N, left with two orphans, P can only accept one of them, no room for both. Thus, removing N is not a option. We do not want to remove node N to remove its entry. Find a node A that is easy to remove and replace N’s entry, then remove node A.
18
Removing an Entry, Node Has Two Children
Node N and its subtrees; (a) entry a is immediately before e, b is immediately after e; (b) after deleting the node that
contained a and replacing e with a.
19
Removing an Entry, Node Has Two Children
The largest entry a in node N's left subtree occurs in the subtree's rightmost node R.
20
Removing an Entry, Node Has Two Children
(a) A binary search tree; (b) after removing Chad;
21
Removing an Entry, Node Has Two Children
(c) after removing Sean; (d) after removing Kathy.
22
Removing an Entry, Node Has Two Children
Algorithm Delete the entry e from a node N that has two children
Find the rightmost node R in N’s left subtree Replace the entry in node N with the entry
that is in node R Delete node R
23
Removing an Entry, Node Has Two Children
Can you think of another way of finding a node R to replace the entry in node N?
24
Remove Chad and Sean using the Second method
25
Removing an Entry in the Root
It will be a special case only if we actually remove the root node. It occurs when the root has at most one child.
(a) Two possible configurations of a root that has one child; (b) after removing the root.
26
Algorithm Remove(binarySearchTree, entry)
To locate the desired entry at a root, then call removeFromRoot(rootNode) //removes the entry in a given root node of a subtree
If(rootNode has two children)
{largestNode = node with the largest entry in the left subtree of rootNode
Replace the entry in rootNode with the entry in largestNode
Remove largestNode from the tree
}
else if (rootNode has a right child)
rootNode = rootNode’s right child
else
rootNode = rootNode’s left child
// assertion: if rootNode was a leaf, it is now null
Return rootNode
27
Efficiency of Operations
Operations add, remove, getEntry require a search that begins at the root.
In the worse case, searches begins at root and examine each node on a path and ends at a leaf.
Maximum number of comparisons is directly proportional to the height, h of the tree
These operations are O(h) Thus we desire the shortest binary search tree we
can create from the data
28
Efficiency of Operations
Two binary search trees that contain the same data.
Shorter tree has efficiency O(log n)
Shorter tree has efficiency O(log n)
29
Efficiency of Operations
The tallest tree has height n if it contains n nodes. The tree looks like a linked chain, and the searching is like searching a linked chain. O(n).
The shortest tree is full. The height of a full tree containing n nodes is log2(n+1). Thus, in the worst case, searching a full binary search tree is an O(logn).
Both full and complete binary search tree can give us O(logn) performance.
30
Importance of Balance
Completely balanced Subtrees of each node have exactly same height,
full tree Other trees are height balanced
Subtrees of each node in the tree differ in height by no more than 1
Completely balanced or height balanced trees are balanced
Concept of balance applies to general trees not just binary tree.
31
Importance of Balance
Some binary trees that are height balanced.
32
Importance of Balance
The order in which entries are added affect the shape of the tree
If entries are added to an empty binary tree Best not to have them sorted first Tree is more balanced if entries are in random
order