I need help with this Java Data Structures Assignment. Thanks Driver Interface M
ID: 3824994 • Letter: I
Question
I need help with this Java Data Structures Assignment. Thanks
Driver Interface Methods
import java.util.Vector;
public interface DriverInterface {
public Vector<TreeItem<Integer,String>> getVectorOfTreeItems();
public BinarySearchTree<Integer,String> createAndPopulateBST(Vector<TreeItem<Integer, String>> treeItems);
}
TreeItem Class
public class TreeItem <K extends Comparable<? super K>, V> {
private K key;
private V value;
public TreeItem(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
TreeNode Class
public class TreeNode<K extends Comparable<? super K>, V> {
private TreeItem<K,V> treeItem;
private TreeNode<K,V> leftChild;
private TreeNode<K,V> rightChild;
private TreeNode<K,V> parent;
public TreeNode(TreeItem<K,V> treeItem) {
this.treeItem = treeItem;
this.leftChild = null;
this.rightChild = null;
this.parent = null;
}
public TreeNode<K, V> getLeftChild() {
return leftChild;
}
public void setLeftChild(TreeNode<K, V> leftChild) {
this.leftChild = leftChild;
}
public TreeNode<K, V> getRightChild() {
return rightChild;
}
public void setRightChild(TreeNode<K, V> rightChild) {
this.rightChild = rightChild;
}
public TreeNode<K, V> getParent() {
return parent;
}
public void setParent(TreeNode<K, V> parent) {
this.parent = parent;
}
public TreeItem<K, V> getTreeItem() {
return treeItem;
}
}
TreeException Class
public class TreeException extends RuntimeException {
public TreeException(String s) {
super(s);
}
}
TreeIterator Class
import java.util.Vector;
public class TreeIterator<K extends Comparable<? super K>,V> implements java.util.Iterator<TreeItem<K,V>> {
private BinarySearchTree<K,V> binarySearchTree;
private TreeNode<K,V> currentNode;
private Vector<TreeNode<K,V>> treeNodes;
public TreeIterator(BinarySearchTree<K,V> binarySearchTree) {
this.binarySearchTree = binarySearchTree;
currentNode = null;
// empty vector indicates no traversal type currently
// selected or end of current traversal has been reached
treeNodes = new Vector<TreeNode<K,V>>();
} // end constructor
public int size() {
return treeNodes.size();
}
public boolean hasNext() {
return !treeNodes.isEmpty();
} // end hasNext
public TreeItem<K,V> next() throws java.util.NoSuchElementException {
currentNode = treeNodes.elementAt(0);
treeNodes.remove(0);
return currentNode.getTreeItem();
} // end next
public void remove() throws UnsupportedOperationException {
throw new UnsupportedOperationException();
} // end remove
public void setPreorder() {
treeNodes.clear();
preorder(binarySearchTree.getRoot());
} // setPreOrder
private void preorder(TreeNode<K,V> treeNode) {
if (treeNode != null) {
treeNodes.add(treeNode);
preorder(treeNode.getLeftChild());
preorder(treeNode.getRightChild());
} // end if
} // end preorder
public void setInorder() {
treeNodes.clear();
inorder(binarySearchTree.getRoot());
} // end setInorder
private void inorder(TreeNode<K,V> treeNode) {
if (treeNode != null) {
inorder(treeNode.getLeftChild());
treeNodes.add(treeNode);
inorder(treeNode.getRightChild());
} // end if
} // end inorder
public void setPostorder() {
treeNodes.clear();
postorder(binarySearchTree.getRoot());
} // end setPostorder
private void postorder(TreeNode<K,V> treeNode) {
if (treeNode != null) {
postorder(treeNode.getLeftChild());
postorder(treeNode.getRightChild());
treeNodes.add(treeNode);
} // end if
} // end postorder
} // end TreeIterator
BinarySearchTree Class
public class BinarySearchTree <K extends Comparable<? super K>, V> {
private TreeNode<K,V> root;
public BinarySearchTree() {
this.root = null;
}
public BinarySearchTree(TreeNode<K,V> root) {
this.root = root;
}
public TreeNode<K, V> getRoot() {
return root;
}
public void setRoot(TreeNode<K, V> root) {
this.root = root;
}
public TreeItem<K,V> getRootItem() throws TreeException {
if (this.root == null) {
throw new TreeException("TreeException: Tree Is Empty, No Root Item");
} else {
return this.root.getTreeItem();
}
}
public boolean isEmpty() {
return (root == null);
}
public void makeEmpty() {
this.root = null;
}
public TreeItem<K,V> find(K key) {
return findItem(this.root, key);
}
private TreeItem<K,V> findItem(TreeNode<K,V> node, K key) {
if (node == null) {
return null;
} else if (node.getTreeItem().getKey().compareTo(key) == 0) {
return node.getTreeItem();
} else if (node.getTreeItem().getKey().compareTo(key) > 0) {
return findItem(node.getLeftChild(), key);
} else {
return findItem(node.getRightChild(), key);
}
}
public void insert(TreeItem<K,V> treeItem) {
this.root = insertItem(this.root, null, treeItem);
}
private TreeNode<K,V> insertItem(TreeNode<K,V> node, TreeNode<K,V> parent, TreeItem<K,V> treeItem) {
if (node == null) {
node = new TreeNode<K,V> (treeItem);
node.setParent(parent);
} else if (node.getTreeItem().getKey().compareTo(treeItem.getKey()) > 0) {
node.setLeftChild(this.insertItem(node.getLeftChild(), node, treeItem));
} else {
node.setRightChild(this.insertItem(node.getRightChild(), node, treeItem));
}
return node;
}
public void delete(K key) throws TreeException {
setRoot(deleteItem(getRoot(), key));
} // end delete
private TreeNode<K,V> deleteItem(TreeNode<K,V> node, K key) {
if (node == null) {
throw new TreeException("TreeException: Item not found" ) ;
} else {
TreeItem<K,V> treeItem = node.getTreeItem();
if (key.compareTo(treeItem.getKey()) == 0) {
// item is in this node, which is the root of a subtree
node = deleteNode(node) ; // delete the item
} else if (key.compareTo(treeItem.getKey()) < 0) {
// search the left subtree
node.setLeftChild(deleteItem(node.getLeftChild(), key));
} else {
// search the right subtree
node.setRightChild(deleteItem(node.getRightChild(), key));
} // end if
} // end if
return node;
} // end deleteItem
private TreeNode<K,V> deleteNode( TreeNode<K,V> node) {
if ((node.getLeftChild() == null) && (node.getRightChild() == null) ) {
// node is a leaf
return null;
} else if (node.getLeftChild() == null) {
// no left child
return node.getRightChild();
} else if (node.getRightChild() == null) {
// no right child
return node.getLeftChild();
} else {
// there are two children:
TreeNode<K,V> successorNode;
successorNode = findLeftmost(node.getRightChild()) ;
node.setTreeItem(successorNode.getTreeItem());
node.setRightChild(deleteLeftmost(node.getRightChild()));
return node;
} // end if
} // end deleteNode
private TreeNode<K,V> findLeftmost( TreeNode<K,V> node) {
if ( node.getLeftChild() == null) {
return node;
} else {
return findLeftmost(node.getLeftChild()) ;
} // end if
} // end findLeftmost
private TreeNode<K,V> deleteLeftmost( TreeNode<K,V> node) {
if (node.getLeftChild() == null) {
return node.getRightChild();
} else {
node.setLeftChild(deleteLeftmost(node.getLeftChild())) ;
return node;
} // end if
} // end deleteLeftmost
}
Explanation / Answer
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
public abstract class GameObject<T extends GameObject<?>>
{
public GameObject(String name)
{
setName(name);
}
private final StringProperty name = new SimpleStringProperty();
public final StringProperty nameProperty() {
return this.name;
}
public final String getName() {
return this.nameProperty().get();
}
public final void setName(final String name) {
this.nameProperty().set(name);
}
private final ObservableList<T> items = FXCollections.observableArrayList();
public ObservableList<T> getItems() {
return items ;
}
public abstract void createAndAddChild(String name);
}