A Binary Search Tree

Implementation
Chapter 26
 Chapter Contents
Getting Started • Whose Node Has One
• An Interface for the Binary Child
Search Tree • Whose Node has Two
• Duplicate Entries Children
• Beginning the Class
• In the Root
Definition • Iterative Implementation
Searching and Retrieving • Recursive Implementation

Traversing Efficiency of Operations

• Importance of Balance
Adding an Entry • Order in Which Nodes Are
• Iterative Implementation
Added
• Recursive Implementation
Implementation of the
Removing an Entry ADT Dictionary
• Whose Node is a leaf 2
 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

3
 Getting Started

Fig. 26-1 A binary search tree of names.

4
 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

5
 An Interface for the
Binary Search Tree

Fig. 26-2 Adding an entry that matches an entry

already in a binary tree … continued →
6
 An Interface for the
Binary Search Tree

Fig. 26-2 (ctd.) Adding an entry that matches an

entry already in a binary tree.
7
 Duplicate Entries
IfIfduplicates
duplicatesare
are
allowed,
allowed,place
placethe
the
duplicate in the
duplicate in the
entry's
entry'sright
rightsubtree.
subtree.

Fig. 26-3 A binary search tree with duplicate entries.

8
 Beginning the Class Definition

import java.util.Iterator;
public class BinarySearchTree extends BinaryTree
implements SearchTreeInterface
{ public BinarySearchTree()
{ super();
} // end default constructor
public BinarySearchTree(Comparable rootEntry)
{ super();
setRootNode(new BinaryNode(rootEntry));
} // end constructor
... Note
Notethat
thatititisisserializable
serializable
because
becauseits
itsbase
baseclass
class
BinaryTree
BinaryTreeisisserializable.
serializable. 9
 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

10
 Searching and Retrieving
The search algorithm
Algorithm bstSearch(binarySearchTree, desiredObject)
// Searches a binary search tree for a given object.
// Returns true if the object is found.
if (binarySearchTree is empty)
return false
else if (desiredObject == object in the root of binarySearchTree)
return true
else if (desiredObject < object in the root of binarySearchTree)
return bstSearch(left subtree of binarySearchTree, desiredObject)
else
return bstSearch(right subtree of binarySearchTree, desiredObject)

11
 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

12
 Adding an Entry

Fig. 26-4 (a) A

binary search tree;
(b) the same tree
after adding Chad.

13
Adding an Entry Recursively

Fig. 26-5 Recursively adding Chad to smaller subtrees

of a binary search tree … continued → 14
Adding an Entry Recursively

Fig. 26-5 (ctd.)

Recursively adding
Chad to smaller
subtrees of a binary
search tree.

15
Adding an Entry Recursively

Fig. 26-6 (a) The method addNode copies its argument

(null) to its local parameter rootNode; (b) rootNode
references a new node that contains Chad
16
Adding an Entry Recursively

Fig. 26-7 After adding a node to the subtree passed to it,

addNode returns a reference to the subtree so it can be
attached to the rest of the original tree. 17
 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
18
Removing an Entry, Node a Leaf

Fig. 26-8 (a) Two possible configurations of leaf

node N; (b) the resulting two possible
configurations after removing node N. 19
 Removing an Entry,
Node Has One Child

Fig. 26-9 (a) Four possible configurations of

node N with one child; (b) resulting two possible
20
configurations after removing node N.
 Removing an Entry,
Node Has Two Children

Fig. 26-10 Two possible configurations of node

N that has two children.
21
 Removing an Entry,
Node Has Two Children

Fig. 26-11 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.
22
 Removing an Entry,
Node Has Two Children

Fig. 26-12 The largest entry a in node N's left subtree

occurs in the subtree's rightmost node R. 23
 Removing an Entry,
Node Has Two Children

Fig. 26-13 (a) A binary search tree; (b)

after removing Chad; 24
 Removing an Entry,
Node Has Two Children

Fig. 26-13 (c) after removing Sean;

25
(d) after removing Kathy.
Removing an Entry in the Root

Fig. 26-14 (a) Two possible configurations of a root that

has one child; (b) after removing the root.
26
 Iterative Implementation

To locate the desired entry

• The remove method given entry to be matched
• If remove finds the entry, it returns the entry
• If not, it returns null

The compareTo method used to make

comparisons with the entries in the tree

27
 Recursive Implementation
Details similar to adding an entry
The public remove method calls a private
recursive remove method
• The public remove returns removed entry
• Private remove must return root of revised
tree
• Thus use parameter that is an instance of
ReturnObject to return the value the public
remove needs
28
 Efficiency of Operations
Operations add, remove, getEntry require a
search that begins at the root
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
29
 Efficiency of Operations

Fig. 26-15 Two

binary search trees
that contain the
same data.

Shorter
Shortertree
treehas
has
efficiency
efficiencyO(log
O(logn)
n) 30
 Importance of Balance
Completely balanced
• Subtrees of each node have exactly same
height
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

31
 Importance of Balance

Fig. 26-16 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

33
 Implementation of the ADT
Dictionary
Interface for a dictionary
import java.util.Iterator;
public interface DictionaryInterface
{ public Object add(Object key, Object value);
public Object remove(Object key);
public Object getValue(Object key);
public boolean contains(Object key);
public Iterator getKeyIterator();
public Iterator getValueIterator();
public boolean isEmpty();
public int getSize();
public void clear();
} // end DictionaryInterface
34
 Implementation of the ADT
Dictionary
Class of data entries (can be private,
internal to class Dictionary)
private class Entry implements Comparable, java.io.Serializable
{ private Object key;
private Object value;
private Entry(Object searchKey, Object dataValue)
{ key = searchKey;
value = dataValue; } // end constructor
public int compareTo(Object other)
{ Comparable cKey = (Comparable)key;
return cKey.compareTo(((Entry)other).key); } // end compareTo
< The class also defines the methods getKey, getValue, and setValue;
no setKey method is provided. >
...
} // end Entry 35
 Implementation of the ADT
Dictionary
Beginning of class Dictionary

import java.util.Iterator;
public class Dictionary implements DictionaryInterface,
java.io.Serializable
{ private SearchTreeInterface bst;
public Dictionary()
{ bst = new BinarySearchTree();|
} // end default constructor
...
} // end Dictionary

36