1)(JAVA) Extend the Binary Search Tree ADT to include a public method leafCount
ID: 3779788 • Letter: 1
Question
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);
}
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)
// 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.
{
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;
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;
}
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)
{
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;
}
}
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;
// 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.
}
Explanation / Answer
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)
// 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
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.
}
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>
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.
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.