added bst classes
This commit is contained in:
Sem van der Hoeven
20
core/src/netwerkprog/game/util/tree/AbstractTree.java
Normal file
20
core/src/netwerkprog/game/util/tree/AbstractTree.java
Normal file
@@ -0,0 +1,20 @@
|
||||
package netwerkprog.game.util.tree;
|
||||
|
||||
public abstract class AbstractTree<E> implements Tree<E> {
|
||||
@Override /** Inorder traversal from the root*/
|
||||
public void inorder() {
|
||||
}
|
||||
|
||||
@Override /** Postorder traversal from the root */
|
||||
public void postorder() {
|
||||
}
|
||||
|
||||
@Override /** Preorder traversal from the root */
|
||||
public void preorder() {
|
||||
}
|
||||
|
||||
@Override /** Return true if the tree is empty */
|
||||
public boolean isEmpty() {
|
||||
return getSize() == 0;
|
||||
}
|
||||
}
|
||||
341
core/src/netwerkprog/game/util/tree/BST.java
Normal file
341
core/src/netwerkprog/game/util/tree/BST.java
Normal file
@@ -0,0 +1,341 @@
|
||||
package netwerkprog.game.util.tree;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class BST<E extends Comparable<E>> extends AbstractTree<E> {
|
||||
protected TreeNode<E> root;
|
||||
protected int size = 0;
|
||||
|
||||
// Helper methode
|
||||
public int sum () {
|
||||
return this.sum(this.getRoot());
|
||||
}
|
||||
|
||||
// Opgave 1b (10 punten): Maak de recursieve methode sum af in de klasse bst.BST. Deze methode telt de getallen
|
||||
// van alle elementen van de binaire zoekboom bij elkaar op. De methode geeft de totale som terug van alle getallen
|
||||
// in de boom.
|
||||
public int sum( TreeNode<E> node ) {
|
||||
// Schrijf hier jouw code...
|
||||
if (node == null) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int nodeValue = (Integer) node.element; // Tip, omdat E nog onbekend is doen we het zo (niet helemaal netjes)
|
||||
return sum(node.left) + sum(node.right);
|
||||
}
|
||||
|
||||
// Helper methode
|
||||
public int totalLeaves () {
|
||||
return this.totalLeaves(this.getRoot());
|
||||
}
|
||||
// Opgave 1c (10 punten): Maak de methode totalLeaves af om de klasse bst.BST. Deze methode telt het aantal
|
||||
// bladeren (leaves) van de gegeven binaire zoekboom en geeft deze terug. Je hoeft deze methode niet recursief te
|
||||
// implementeren. Het mag wel.
|
||||
public int totalLeaves ( TreeNode<E> node ) {
|
||||
if (node == null) {
|
||||
return 0;
|
||||
}
|
||||
if (node.left == null && node.right == null) {
|
||||
return 1;
|
||||
}
|
||||
return totalLeaves(node.left) + totalLeaves(node.right);
|
||||
}
|
||||
|
||||
/** Create a default binary tree */
|
||||
public BST() {
|
||||
}
|
||||
|
||||
/** Create a binary tree from an array of objects */
|
||||
public BST(E[] objects) {
|
||||
for (int i = 0; i < objects.length; i++)
|
||||
insert(objects[i]);
|
||||
}
|
||||
|
||||
@Override /** Returns true if the element is in the tree */
|
||||
public boolean search(E e) {
|
||||
return search(e, root);
|
||||
}
|
||||
|
||||
private boolean search(E e, TreeNode<E> tree)
|
||||
{
|
||||
// nog niet correct
|
||||
if (tree == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (e.compareTo(tree.element) == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (e.compareTo(tree.element) < 0)
|
||||
{
|
||||
return search(e, tree.left);
|
||||
}
|
||||
|
||||
else // (e.compareTo(tree.element) > 0)
|
||||
{
|
||||
return search(e, tree.right);
|
||||
}
|
||||
}
|
||||
|
||||
@Override /** Insert element o into the binary tree
|
||||
* Return true if the element is inserted successfully */
|
||||
public boolean insert(E e) {
|
||||
if (root == null) {
|
||||
root = createNewNode(e); // Create a new root
|
||||
size++;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return insert(e, root);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/** Insert element o into the binary tree
|
||||
* Return true if the element is inserted successfully
|
||||
pre: root != null
|
||||
*/
|
||||
public boolean insert(E e, TreeNode<E> tree) {
|
||||
if (e.compareTo(tree.element) == 0) {
|
||||
return false; // Duplicate node not inserted
|
||||
}
|
||||
else if (e.compareTo(tree.element) < 0 && tree.left != null)
|
||||
return insert(e, tree.left);
|
||||
|
||||
else if (e.compareTo(tree.element) > 0 && tree.right != null)
|
||||
return insert(e, tree.right);
|
||||
|
||||
// Create the new node and attach it to the parent node
|
||||
else {
|
||||
if (e.compareTo(tree.element) < 0) {
|
||||
tree.left = createNewNode(e);
|
||||
}
|
||||
else {
|
||||
tree.right = createNewNode(e);
|
||||
}
|
||||
size++;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
protected TreeNode<E> createNewNode(E e) {
|
||||
return new TreeNode<E>(e);
|
||||
}
|
||||
|
||||
@Override /** Inorder traversal from the root*/
|
||||
public void inorder() {
|
||||
inorder(root);
|
||||
}
|
||||
|
||||
/** Inorder traversal from a subtree */
|
||||
protected void inorder(TreeNode<E> root) {
|
||||
if (root == null) return;
|
||||
inorder(root.left);
|
||||
System.out.print(root.element + " ");
|
||||
inorder(root.right);
|
||||
}
|
||||
|
||||
@Override /** Postorder traversal from the root */
|
||||
public void postorder() {
|
||||
postorder(root);
|
||||
}
|
||||
|
||||
/** Postorder traversal from a subtree */
|
||||
protected void postorder(TreeNode<E> root) {
|
||||
if (root == null) return;
|
||||
postorder(root.left);
|
||||
postorder(root.right);
|
||||
System.out.print(root.element + " ");
|
||||
}
|
||||
|
||||
@Override /** Preorder traversal from the root */
|
||||
public void preorder() {
|
||||
preorder(root);
|
||||
}
|
||||
|
||||
/** Preorder traversal from a subtree */
|
||||
protected void preorder(TreeNode<E> root) {
|
||||
if (root == null) return;
|
||||
System.out.print(root.element + " ");
|
||||
preorder(root.left);
|
||||
preorder(root.right);
|
||||
}
|
||||
|
||||
/** This inner class is static, because it does not access
|
||||
any instance members defined in its outer class */
|
||||
public static class TreeNode<E extends Comparable<E>> {
|
||||
protected E element;
|
||||
protected TreeNode<E> left;
|
||||
protected TreeNode<E> right;
|
||||
|
||||
public TreeNode(E e) {
|
||||
element = e;
|
||||
}
|
||||
}
|
||||
|
||||
@Override /** Get the number of nodes in the tree */
|
||||
public int getSize() {
|
||||
return size;
|
||||
}
|
||||
|
||||
/** Returns the root of the tree */
|
||||
public TreeNode<E> getRoot() {
|
||||
return root;
|
||||
}
|
||||
|
||||
/** Returns a path from the root leading to the specified element */
|
||||
public java.util.ArrayList<TreeNode<E>> path(E e) {
|
||||
java.util.ArrayList<TreeNode<E>> list =
|
||||
new java.util.ArrayList<TreeNode<E>>();
|
||||
TreeNode<E> current = root; // Start from the root
|
||||
|
||||
while (current != null) {
|
||||
list.add(current); // Add the node to the list
|
||||
if (e.compareTo(current.element) < 0) {
|
||||
current = current.left;
|
||||
}
|
||||
else if (e.compareTo(current.element) > 0) {
|
||||
current = current.right;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
return list; // Return an array list of nodes
|
||||
}
|
||||
|
||||
@Override /** Delete an element from the binary tree.
|
||||
* Return true if the element is deleted successfully
|
||||
* Return false if the element is not in the tree */
|
||||
public boolean delete(E e) {
|
||||
// Locate the node to be deleted and also locate its parent node
|
||||
TreeNode<E> parent = null;
|
||||
TreeNode<E> current = root;
|
||||
while (current != null) {
|
||||
if (e.compareTo(current.element) < 0) {
|
||||
parent = current;
|
||||
current = current.left;
|
||||
}
|
||||
else if (e.compareTo(current.element) > 0) {
|
||||
parent = current;
|
||||
current = current.right;
|
||||
}
|
||||
else
|
||||
break; // Element is in the tree pointed at by current
|
||||
}
|
||||
|
||||
if (current == null)
|
||||
return false; // Element is not in the tree
|
||||
|
||||
// Case 1: current has no left child
|
||||
if (current.left == null) {
|
||||
// Connect the parent with the right child of the current node
|
||||
if (parent == null) {
|
||||
root = current.right;
|
||||
}
|
||||
else {
|
||||
if (e.compareTo(parent.element) < 0)
|
||||
parent.left = current.right;
|
||||
else
|
||||
parent.right = current.right;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Case 2: The current node has a left child
|
||||
// Locate the rightmost node in the left subtree of
|
||||
// the current node and also its parent
|
||||
TreeNode<E> parentOfRightMost = current;
|
||||
TreeNode<E> rightMost = current.left;
|
||||
|
||||
while (rightMost.right != null) {
|
||||
parentOfRightMost = rightMost;
|
||||
rightMost = rightMost.right; // Keep going to the right
|
||||
}
|
||||
|
||||
// Replace the element in current by the element in rightMost
|
||||
current.element = rightMost.element;
|
||||
|
||||
// Eliminate rightmost node
|
||||
if (parentOfRightMost.right == rightMost)
|
||||
parentOfRightMost.right = rightMost.left;
|
||||
else
|
||||
// Special case: parentOfRightMost == current
|
||||
parentOfRightMost.left = rightMost.left;
|
||||
}
|
||||
|
||||
size--;
|
||||
return true; // Element deleted successfully
|
||||
}
|
||||
|
||||
@Override /** Obtain an iterator. Use inorder. */
|
||||
public java.util.Iterator<E> iterator() {
|
||||
return new InorderIterator();
|
||||
}
|
||||
|
||||
// Inner class InorderIterator
|
||||
private class InorderIterator implements java.util.Iterator<E> {
|
||||
// Store the elements in a list
|
||||
private java.util.ArrayList<E> list =
|
||||
new java.util.ArrayList<E>();
|
||||
private int current = 0; // Point to the current element in list
|
||||
|
||||
public InorderIterator() {
|
||||
inorder(); // Traverse binary tree and store elements in list
|
||||
}
|
||||
|
||||
/** Inorder traversal from the root*/
|
||||
private void inorder() {
|
||||
inorder(root);
|
||||
}
|
||||
|
||||
/** Inorder traversal from a subtree */
|
||||
private void inorder(TreeNode<E> root) {
|
||||
if (root == null)return;
|
||||
inorder(root.left);
|
||||
list.add(root.element);
|
||||
inorder(root.right);
|
||||
}
|
||||
|
||||
@Override /** More elements for traversing? */
|
||||
public boolean hasNext() {
|
||||
if (current < list.size())
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override /** Get the current element and move to the next */
|
||||
public E next() {
|
||||
return list.get(current++);
|
||||
}
|
||||
|
||||
@Override /** Remove the current element */
|
||||
public void remove() {
|
||||
delete(list.get(current)); // Delete the current element
|
||||
list.clear(); // Clear the list
|
||||
inorder(); // Rebuild the list
|
||||
}
|
||||
}
|
||||
|
||||
/** Remove all elements from the tree */
|
||||
public void clear() {
|
||||
root = null;
|
||||
size = 0;
|
||||
}
|
||||
|
||||
// if (tree == null) {
|
||||
// return false;
|
||||
// }
|
||||
// else if (e.compareTo(tree.element) > 0) {
|
||||
// return search(e, tree.right);
|
||||
// }
|
||||
// else if (e.compareTo(tree.element) < 0) {
|
||||
// return search(e, tree.left);
|
||||
// }
|
||||
// else {
|
||||
// return true;
|
||||
// }
|
||||
//
|
||||
}
|
||||
29
core/src/netwerkprog/game/util/tree/Tree.java
Normal file
29
core/src/netwerkprog/game/util/tree/Tree.java
Normal file
@@ -0,0 +1,29 @@
|
||||
package netwerkprog.game.util.tree;
|
||||
|
||||
public interface Tree<E> extends Iterable<E> {
|
||||
/** Return true if the element is in the tree */
|
||||
public boolean search(E e);
|
||||
|
||||
/** Insert element o into the binary tree
|
||||
* Return true if the element is inserted successfully */
|
||||
public boolean insert(E e);
|
||||
|
||||
/** Delete the specified element from the tree
|
||||
* Return true if the element is deleted successfully */
|
||||
public boolean delete(E e);
|
||||
|
||||
/** Inorder traversal from the root*/
|
||||
public void inorder();
|
||||
|
||||
/** Postorder traversal from the root */
|
||||
public void postorder();
|
||||
|
||||
/** Preorder traversal from the root */
|
||||
public void preorder();
|
||||
|
||||
/** Get the number of nodes in the tree */
|
||||
public int getSize();
|
||||
|
||||
/** Return true if the tree is empty */
|
||||
public boolean isEmpty();
|
||||
}
|
||||
16
core/src/netwerkprog/game/util/tree/TreeNode.java
Normal file
16
core/src/netwerkprog/game/util/tree/TreeNode.java
Normal file
@@ -0,0 +1,16 @@
|
||||
package netwerkprog.game.util.tree;
|
||||
|
||||
public class TreeNode<E> {
|
||||
|
||||
protected E element;
|
||||
protected TreeNode<E> left;
|
||||
protected TreeNode<E> right;
|
||||
|
||||
public TreeNode(E e) {
|
||||
this.element = e;
|
||||
}
|
||||
|
||||
public E getElement() {
|
||||
return element;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user