The document extends a Binary Search Tree (BST) interface to include a new public method called leafCount that returns the number of leaf nodes in the tree. It also provides the BinarySearchTree and BSTInterface files that implement the BST with methods for common operations like adding and removing nodes, and traversing the tree in different orders.

1. 1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount that returns
the number of leaf nodes in the tree.
Thank You in Advanced.
Below, I also have attached the BinarySearchTree and the Interface File.
BinarySearchTree:
//----------------------------------------------------------------------------
// BinarySearchTree.java by Dale/Joyce/Weems Chapter 8
//
// Defines all constructs for a reference-based BST
//----------------------------------------------------------------------------
package ch08.trees;
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public class BinarySearchTree>
implements BSTInterface
{
protected BSTNode root; // reference to the root of this BST
boolean found; // used by remove
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of info
protected LinkedUnbndQueue preOrderQueue; // queue of info
protected LinkedUnbndQueue postOrderQueue; // queue of info
public BinarySearchTree()
// Creates an empty BST object.
{
root = null;
}
public boolean isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
{
return (root == null);
}

2. private int recSize(BSTNode tree)
// Returns the number of elements in tree.
{
if (tree == null)
return 0;
else
return recSize(tree.getLeft()) + recSize(tree.getRight()) + 1;
}
public int size()
// Returns the number of elements in this BST.
{
return recSize(root);
}
public int size2()
// Returns the number of elements in this BST.
{
int count = 0;
if (root != null)
{
LinkedStack> hold = new LinkedStack>();
BSTNode currNode;
hold.push(root);
while (!hold.isEmpty())
{
currNode = hold.top();
hold.pop();
count++;
if (currNode.getLeft() != null)
hold.push(currNode.getLeft());
if (currNode.getRight() != null)
hold.push(currNode.getRight());
}
}
return count;
}
private boolean recContains(T element, BSTNode tree)

3. // Returns true if tree contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
if (tree == null)
return false; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // element is found
}
public boolean contains (T element)
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
{
return recContains(element, root);
}
private T recGet(T element, BSTNode tree)
// Returns an element e from tree such that e.compareTo(element) == 0;
// if no such element exists, returns null.
{
if (tree == null)
return null; // element is not found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree
else
return tree.getInfo(); // element is found
}
public T get(T element)
// Returns an element e from this BST such that e.compareTo(element) == 0;
// if no such element exists, returns null.

4. {
return recGet(element, root);
}
private BSTNode recAdd(T element, BSTNode tree)
// Adds element to tree; tree retains its BST property.
{
if (tree == null)
// Addition place found
tree = new BSTNode(element);
else if (element.compareTo(tree.getInfo()) <= 0)
tree.setLeft(recAdd(element, tree.getLeft())); // Add in left subtree
else
tree.setRight(recAdd(element, tree.getRight())); // Add in right subtree
return tree;
}
public void add (T element)
// Adds element to this BST. The tree retains its BST property.
{
root = recAdd(element, root);
}
private T getPredecessor(BSTNode tree)
// Returns the information held in the rightmost node in tree
{
while (tree.getRight() != null)
tree = tree.getRight();
return tree.getInfo();
}
private BSTNode removeNode(BSTNode tree)
// Removes the information at the node referenced by tree.
// The user's data in the node referenced by tree is no
// longer in the tree. If tree is a leaf node or has only
// a non-null child pointer, the node pointed to by tree is
// removed; otherwise, the user's data is replaced by its
// logical predecessor and the predecessor's node is removed.
{
T data;

5. if (tree.getLeft() == null)
return tree.getRight();
else if (tree.getRight() == null)
return tree.getLeft();
else
{
data = getPredecessor(tree.getLeft());
tree.setInfo(data);
tree.setLeft(recRemove(data, tree.getLeft()));
return tree;
}
}
private BSTNode recRemove(T element, BSTNode tree)
// Removes an element e from tree such that e.compareTo(element) == 0
// and returns true; if no such element exists, returns false.
{
if (tree == null)
found = false;
else if (element.compareTo(tree.getInfo()) < 0)
tree.setLeft(recRemove(element, tree.getLeft()));
else if (element.compareTo(tree.getInfo()) > 0)
tree.setRight(recRemove(element, tree.getRight()));
else
{
tree = removeNode(tree);
found = true;
}
return tree;
}
public boolean remove (T element)
// Removes an element e from this BST such that e.compareTo(element) == 0
// and returns true; if no such element exists, returns false.
{
root = recRemove(element, root);
return found;
}

6. private void inOrder(BSTNode tree)
// Initializes inOrderQueue with tree elements in inOrder order.
{
if (tree != null)
{
inOrder(tree.getLeft());
inOrderQueue.enqueue(tree.getInfo());
inOrder(tree.getRight());
}
}
private void preOrder(BSTNode tree)
// Initializes preOrderQueue with tree elements in preOrder order.
{
if (tree != null)
{
preOrderQueue.enqueue(tree.getInfo());
preOrder(tree.getLeft());
preOrder(tree.getRight());
}
}
private void postOrder(BSTNode tree)
// Initializes postOrderQueue with tree elements in postOrder order.
{
if (tree != null)
{
postOrder(tree.getLeft());
postOrder(tree.getRight());
postOrderQueue.enqueue(tree.getInfo());
}
}
public int reset(int orderType)
// Initializes current position for an iteration through this BST
// in orderType order. Returns current number of nodes in the BST.
{
int numNodes = size();
if (orderType == INORDER)

7. {
inOrderQueue = new LinkedUnbndQueue();
inOrder(root);
}
else
if (orderType == PREORDER)
{
preOrderQueue = new LinkedUnbndQueue();
preOrder(root);
}
if (orderType == POSTORDER)
{
postOrderQueue = new LinkedUnbndQueue();
postOrder(root);
}
return numNodes;
}
public T getNext (int orderType)
// Preconditions: The BST is not empty
// The BST has been reset for orderType
// The BST has not been modified since the most recent reset
// The end of orderType iteration has not been reached
//
// Returns the element at the current position on this BST for orderType
// and advances the value of the current position based on the orderType.
{
if (orderType == INORDER)
return inOrderQueue.dequeue();
else
if (orderType == PREORDER)
return preOrderQueue.dequeue();
else
if (orderType == POSTORDER)
return postOrderQueue.dequeue();
else return null;
}

8. }
BSTInterface:
//----------------------------------------------------------------------------
// BSTInterface.java by Dale/Joyce/Weems Chapter 8
//
// Interface for a class that implements a binary search tree (BST).
//
// The trees are unbounded and allow duplicate elements, but do not allow null
// elements. As a general precondition, null elements are not passed as
// arguments to any of the methods.
//
// The tree supports iteration through its elements in INORDER, PREORDER,
// and POSTORDER.
//----------------------------------------------------------------------------
package ch08.trees;
public interface BSTInterface>
{
// used to specify traversal order
static final int INORDER = 1;
static final int PREORDER = 2;
static final int POSTORDER = 3;
boolean isEmpty();
// Returns true if this BST is empty; otherwise, returns false.
int size();
// Returns the number of elements in this BST.
boolean contains (T element);
// Returns true if this BST contains an element e such that
// e.compareTo(element) == 0; otherwise, returns false.
boolean remove (T element);
// Removes an element e from this BST such that e.compareTo(element) == 0
// and returns true; if no such element exists, returns false.
T get(T element);
// Returns an element e from this BST such that e.compareTo(element) == 0;

9. // if no such element exists, returns null.
void add (T element);
// Adds element to this BST. The tree retains its BST property.
int reset(int orderType);
// Initializes current position for an iteration through this BST
// in orderType order. Returns current number of nodes in the BST.
T getNext (int orderType);
// Preconditions: The BST is not empty
// The BST has been reset for orderType
// The BST has not been modified since the most recent reset
// The end of orderType iteration has not been reached
//
// Returns the element at the current position on this BST for orderType
// and advances the value of the current position based on the orderType.
}
Solution
import ch05.queues.*;
import ch03.stacks.*;
import support.BSTNode;
public category BinarySearchTree>
implements BSTInterface
relevance the basis of this BST
boolean found; // utilized by take away
// for traversals
protected LinkedUnbndQueue inOrderQueue; // queue of information
protected LinkedUnbndQueue preOrderQueue; // queue of information
protected LinkedUnbndQueue postOrderQueue; // queue of information
public BinarySearchTree()
// Creates Associate in Nursing empty BST object.
public mathematician isEmpty()
// Returns true if this BST is empty; otherwise, returns false.
private int recSize(BSTNode tree)

10. // Returns the quantity of components in tree.
public int size()
// Returns the quantity of components during this BST.
public int size2()
// Returns the quantity of components during this BST.
}
return count;
}
private mathematician recContains(T part, BSTNode tree)
// Returns true if tree contains a part e such
// e.compareTo(element) == zero; otherwise, returns false.
{
if (tree == null)
return false; // part isn't found
else if (element.compareTo(tree.getInfo()) < 0)
return recContains(element, tree.getLeft()); // Search left subtree
else if (element.compareTo(tree.getInfo()) > 0)
return recContains(element, tree.getRight()); // Search right subtree
else
return true; // part is found
}
public mathematician contains (T element)
// Returns true if this BST contains a part e such
// e.compareTo(element) == zero; otherwise, returns false.
private T recGet(T part, BSTNode tree)
// Returns a part e from tree such e.compareTo(element) == zero;
// if no such part exists, returns null.
{
if (tree == null)
return null; // part isn't found
else if (element.compareTo(tree.getInfo()) < 0)
return recGet(element, tree.getLeft()); // get from left subtree
else
if (element.compareTo(tree.getInfo()) > 0)
return recGet(element, tree.getRight()); // get from right subtree

11. else
return tree.getInfo(); // part is found
}
public T get(T element)
// Returns a part e from this BST such e.compareTo(element) == 0;
// if no such part exists, returns null.
private BSTNode recAdd(T part, BSTNode tree)
// Adds part to tree; tree retains its BST property.
public void add (T element)
// Adds part to the current BST. The tree retains its BST property.
private T getPredecessor(BSTNode tree)
// Returns the knowledge command within the right node in tree
private BSTNode removeNode(BSTNode tree)
// Removes the knowledge at the node documented by tree.
// The user's information within the node documented by tree is not any
// longer within the tree. If tree could be a leaf node or has solely
// a non-null kid pointer, the node pointed to by tree is
// removed; otherwise, the user's information is replaced by its
// logical forerunner and therefore the predecessor's node is removed.
}
private BSTNode recRemove(T part, BSTNode tree)
// Removes a part e from tree such e.compareTo(element) == 0
// and returns true; if no such part exists, returns false.
return tree;
}
public mathematician take away (T element)
// Removes a part e from this BST such e.compareTo(element) == 0
// and returns true; if no such part exists, returns false.
private void inOrder(BSTNode tree)
// Initializes inOrderQueue with tree components in inOrder order.
}
private void preOrder(BSTNode tree)
// Initializes preOrderQueue with tree components in preOrder order.
}
private void postOrder(BSTNode tree)
// Initializes postOrderQueue with tree components in postOrder order.

12. }
public int reset(int orderType)
// Initializes current position for Associate in Nursing iteration through this BST
// in orderType order. Returns current variety of nodes within the BST.
else
if (orderType == PREORDER)
if (orderType == POSTORDER)
return numNodes;
}
public T getNext (int orderType)
// Preconditions: The BST isn't empty
// The BST has been reset for orderType
// The BST has not been changed since the foremost recent reset
// the tip of orderType iteration has not been reached
//
// Returns the part at the present position on this BST for orderType
// and advances the worth of the present position supported the orderType.
come back null;
}
}
BSTInterface:
//----------------------------------------------------------------------------
// BSTInterface.java by Dale/Joyce/Weems Chapter eight
//
// Interface for a category that implements a binary search tree (BST).
//
// The trees square measure boundless and permit duplicate components, however don't enable
null
// components. As a general precondition, null components don't seem to be passed as
// arguments to any of the strategies.
//
// The tree supports iteration through its components in INORDER, PREORDER,
// and POSTORDER.
//----------------------------------------------------------------------------
package ch08.trees;
public interface BSTInterface>

13. accustomed specify traversal order
static final int INORDER = 1;
static final int PREORDER = 2;
static final int POSTORDER = 3;
boolean isEmpty();
// Returns true if this BST is empty; otherwise, returns false.
int size();
// Returns the quantity of components during this BST.
boolean contains (T element);
// Returns true if this BST contains a part e such
// e.compareTo(element) == 0; otherwise, returns false.
boolean take away (T element);
// Removes a part e from this BST such e.compareTo(element) == 0
// and returns true; if no such part exists, returns false.
T get(T element);
// Returns a part e from this BST such e.compareTo(element) == 0;
// if no such part exists, returns null.
void add (T element);
// Adds part to the current BST. The tree retains its BST property.
int reset(int orderType);
// Initializes current position for Associate in Nursing iteration through this BST
// in orderType order. Returns current variety of nodes within the BST.
T getNext (int orderType);
// Preconditions: The BST isn't empty
// The BST has been reset for orderType
// The BST has not been changed since the foremost recent reset
// the tip of orderType iteration has not been reached
//
// Returns the part at the present position on this BST for orderType
// and advances the worth of the present position supported the orderType.
}