META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx

META-INF/MANIFEST.MF
Manifest-Version: 1.0
.classpath
PriorityQueue.classpublicsynchronizedclass PriorityQueue {
Heap q;
public void PriorityQueue(int, java.util.Comparator);
public Object peek();
public Object remove();
void add(Object);
boolean isEmpty();
public int size();
}
PriorityQueue.javaPriorityQueue.javaimport java.util.Comparat
or;
publicclassPriorityQueue<E>{
Heap q;
/**
*PriorityQueue initializes the queue.
*
* @param initialCapacity an int that is the heaps initial size.

* @param comparator the priority of various imputs.
*/
publicPriorityQueue(int initialCapacity,Comparator<?super E>
comparator){
q=newHeap(initialCapacity,comparator);
}
/**
* Peek, returns the next item in the queue without removing
it.
*
* If it is empty then null is returned.
* @return the next item in the queue.
*/
public E peek(){
if(q.size()==0){
returnnull;
}
return(E) q.findMax();
}
/**
* This removes the first item from the queue.
*
* It returns null if the queue is empty.
* @return the first item in the queue.
*/
public E remove(){
if(q.size()==0){
returnnull;
}
return(E) q.removeMax();
}
/**

* This adds item to the queue
* @param item that is added to the queue.
*/
void add(E item){
q.insert(item);
}
/**
* isEmpty returns if the queue is empty or not.
*
* @return boolean if the queue is empty or not.
*/
boolean isEmpty(){
if(q.size()!=0){
returnfalse;
}
returntrue;
}
/**
* size returns the size of the queue.
*
* @return int the size of the queue.
*/
publicint size(){
return q.size();
}
}
ArithmeticExpression.classpublicsynchronizedclass
ArithmeticExpression {
BinaryTree t;
java.util.ArrayList list;
String equation;
void ArithmeticExpression(String) throws
java.text.ParseException;

public String toString(BinaryTree);
public String toPostfixString(BinaryTree);
void setVariable(String, int) throws
java.rmi.NotBoundException;
public int evaluate(BinaryTree);
}
ArithmeticExpression.javaArithmeticExpression.javaimport java
.rmi.NotBoundException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Stack;
/**
* ArithmeticExpression takes equations in the form of strings c
reates a binary
* tree, and can return either the regular or postfix equation. It a
lso allows
* them to be calculated.
*
*
* Extra Credit:
* ** it can handle spaces or no spaces in the string inputted. **
it can return
* regular or postfix notation
*
* @author tai-lanhirabayashi
*
*/
publicclassArithmeticExpression{
BinaryTree t;
ArrayList list;
String equation;

/**
* ArithmeticExpression is the construction which takes in a
space
* delimitated equation containing "*,/,+,-
" symbols and converts it into a
* binary tree.
*
* If the expression is not valid it will throw a ParseExceptio
n. This is
* the constructor. It will take a String containing the express
ion.
*
* ** The equation can take in stings delimitated by spaces, o
r withot any
* spaces. If it contains a mix, then the non spaced part(s) wil
l be
* considered to be a variable.
*
* @param expression
* @throws ParseException
* if the string is not a valid equation
*/
@SuppressWarnings({"unchecked","rawtypes"})
ArithmeticExpression(String expression)throwsParseException{
//hold the string globally
equation = expression;
//create a new arrayList to be used globally that holds the variab
les
list =newArrayList();
//split the string
String[] s = expression.split(" ");
// create a stack of tree's and operators

Stack tree =newStack();
Stack operator =newStack();
//create the string Next
String next ="";
// if the string expression doesnt contain spaces
if(!expression.contains(" ")){
int i =0;
//if it starts with an operator throw an error this cannot be.
if(expression.charAt(0)=='+'|| expression.charAt(0)=='*'
|| expression.charAt(0)=='-'
|| expression.charAt(0)=='/'){
System.out.println("this equation starts with a operator.");
thrownewParseException(expression,0);
}
// if the expression ends with an operator throw an error this can
not be.
if(expression.charAt(expression.length()-1)=='+'
|| expression.charAt(expression.length()-1)=='*'
|| expression.charAt(expression.length()-1)=='-'
|| expression.charAt(expression.length()-1)=='/'){
System.out.println("this equation ends with a operator.");
thrownewParseException(expression, expression.length());
}
//go through each characer in the expression and see if its a num
ber/variable, or operator.
while(i < expression.length()){
if(expression.charAt(i)=='+'|| expression.charAt(i)=='*'
|| expression.charAt(i)=='-'
|| expression.charAt(i)=='/'){
// if the character is a operator add a space to the begining and f

ront and add it to the "next" string
String str =String.valueOf(expression.charAt(i));
next = next +" "+ str +" ";
}else{
// if its an operator add it to the end of the "next" string.
next = next + expression.charAt(i);
}
// increase i to move to the next character.
i++;
}
// split the new string with added spaces.
s = next.split(" ");
}
// if the string still doesnt exist throw the error.
if(s.length ==0){
System.out
.println("there has been an error. You have not entered a string
with any characters");
}
// make sure there arent two operators in a row.
for(int i =0; i < s.length; i++){
if(i >=1
&&(s[i].equals("+")|| s[i].equals("-")
|| s[i].equals("*")|| s[i].equals("/"))){
if(s[i -1].equals("+")|| s[i -1].equals("-")
|| s[i -1].equals("*")|| s[i -1].equals("/")){
System.out
.println("there were two operators in a row. The equation is not
valid.");
thrownewParseException(expression, i);

}
}
// check to make sure there arent two operands in a row in the St
ring[]
if(i >=1
&&(s[i].equals("+")==false&& s[i].equals("-")==false
&& s[i].equals("*")==false&& s[i].equals("/")==false)){
if(s[i -1].equals("+")==false
&& s[i -1].equals("-")==false
&& s[i -1].equals("*")==false
&& s[i -1].equals("/")==false){
System.out
.println("there were two operands in a row. The equation is not
valid.");
}
}
// if its a number create a new tree node, and add it to the tree st
ack
if(s[i].equals("+")==false&& s[i].equals("-")==false
&& s[i].equals("*")==false&& s[i].equals("/")==false){
BinaryTree o =newBinaryTree(null, s[i],null);
tree.add(o);
}elseif(operator.empty()|| s[i].equals("*")|| s[i].equals("/")){
//if its a * or / symbol hold it to ensure order of operation
operator.push(s[i]);
}else{
//group the tree's together.
while(operator.empty()==false){
String operatorHeld =(String) operator.pop();

BinaryTree one =(BinaryTree) tree.pop();
BinaryTree two =(BinaryTree) tree.pop();
BinaryTree n =newBinaryTree(one, operatorHeld, two);
tree.push(n);
}
}
}
// at the end ensure that the operator is empty.
tree.push(n);
}
//if there is more than 1 tree at the end something went wrong
// this should not occur as it should have been caught earlier
// this is just to ensure completeness.
if(tree.size()>=2){
System.out
.println("this expression is invalid. There were more operands t
han operators.");
System.out
.println("this should not occur it should have been caught earlie
r");
while(tree.empty()==false){
return;
}
}
//if there are still operators there is something wrong

if(operator.empty()==false){
System.out
r.");
System.out
.println("there were too many operators in the string the progra
m cannot continue.");
{
return;
}
}
// set the tree globally
t =(BinaryTree) tree.pop();
}
/**
* toString returns the String equation of that the passed in bi
nary tree
* represents.
*
* @param tree
* that represents an equation
* @return the String that is represented by the passed in Bin
aryTree.
*/
@SuppressWarnings("rawtypes")
publicString toString(BinaryTree tree){
// if its a leaf return its value
if(tree.isLeaf()==true){
return(String) tree.getValue();
}else{
//else combine each parent child combination

//call recursively, and contain each call in parenthesis.
String s =("("+ toString(tree.getLeftChild())+ tree.getValue()
+ toString(tree.getRightChild())+")");
return s;
}
}
/**
* toPostfixString returns the string containing the parsed exp
ression in
* postFix notation with spaces between numbers and operato
rs to ensure clarity.
*
* @param tree that represents an equation
aryTree in
* postfix form.
*/
@SuppressWarnings("unchecked")
publicString toPostfixString(BinaryTree tree){
//if its a leaf return its value
}else{
//otherwise call recursively down the tree
// and add the operator to the end of the two operands.
// also add spaces to allow numbers to be seen individually.
String s = toPostfixString(tree.getRightChild())+" "
+ toPostfixString(tree.getLeftChild())+" "
+ tree.getValue();
System.out.println("this is what s is "+ s);
return s;
}

}
/**
* This allows the user to set a value for a variable in the exp
ression. If
* the variable does not exist in the function, throw a NotBou
ndException.
*
* @param name of the variable
* @param value that the variable has
* @throws NotBoundException if the variable is not used in
the equation
*/
void setVariable(String name,int value)throwsNotBoundExcepti
on{
//Note var, is not a Var it is a seperate class that is an object.
//if the equation string doesnt contain the variable throw an erro
r
if(!equation.contains(name)){
thrownewNotBoundException();
}
// else continue and check if the var object is already in the list
for(int i =0; i < list.size(); i++){
var v =(var) list.get(i);
if(v.getName().equals(name)){
//if so change the value of the var object
v.setValue(value);
return;
}
}
// otherwise add the var object to the list.

list.add(new var(name, value));
}
/**
* Evaluate returns the integer result of the expression.
*
* Variables that are not declared are calculated at 0.
*
* @return the value of the equation
*/
@SuppressWarnings("unused")
publicint evaluate(BinaryTree tree){
//if it is a leaf
String s =(String) tree.getValue();
//if all characters are numbers simply skip down to return the in
teger value.
for(int i =0; i < s.length(); i++){
if(s.charAt(i)=='0'|| s.charAt(i)==('1')
|| s.charAt(i)=='2'|| s.charAt(i)=='3'
|| s.charAt(i)=='8'|| s.charAt(i)=='9'){
}else{
//if there are non numeric characters check if the list has their v
alues
for(int j =0; j < list.size(); j++){
var h =(var) list.get(j);
if(h.getName().equals(s)){
return h.getValue();
}

}
//otherwise tell the user that this variable cannot be found and t
hat its value is calulated at 0
System.out.println("this variable "+ s
+" cannot be found! Its value will be 0.");
return0;
}
returnInteger.parseInt((String) tree.getValue());
}
}
//find the left and right values of the tree
int left = evaluate(tree.getLeftChild());
int right = evaluate(tree.getRightChild());
//calculate appropriately.
if(tree.getValue().equals("*")){
return left * right;
}elseif(tree.getValue().equals("/")){
return left / right;
}elseif(tree.getValue().equals("+")){
return left + right;
}
return left - right;
}
}
Map.classpublicsynchronizedclass Map {
BSTMap root;

BSTMap found;
java.util.TreeSet set;
public void Map();
public void put(Comparable, Object);
public Object get(Comparable);
public boolean containsKey(Comparable);
private BSTMap getBSTMap(Comparable);
public Object remove(Comparable);
private BSTMap sucessor(BSTMap);
public java.util.Set keySet();
}
Map.javaMap.javaimport java.util.Set;
import java.util.TreeSet;
publicclassMap<K extendsComparable<K>,V>{
BSTMap root;
BSTMap found;
TreeSet<K> set;
/**
* Map initializes the map.
*/
publicMap(){
set=newTreeSet<K>();
root=null;
found=null;
}
/**
* put loads the Key and value into a BSTMap object, and the
key into the set.

*
* If the key already exists the value is changed to the new va
lue.
* @param key the K key value
* @param value the V value value
*/
publicvoid put(K key, V value){
//if the root is null this is the root
if(root==null){
root=newBSTMap(key,value);
set.add(key);
//if the key exists then change the value
}elseif(get(key)!=null){
getBSTMap(key).obj.value=value;
}else{
//otherwise create a new BSTMap
BSTMap i =newBSTMap(key,value);
//add it to the set
set.add(key);
//and find its place in the BSTmap tree.No key can be identical.
boolean done=false;
BSTMap c= root;
while(done==false){
//if it is bigger go right
if(key.compareTo((K) c.obj.getKey())>=0){
if(c.getRight()==null){
c.setRight(i);
done=true;
}else{
c=c.getRight();

}
//if it is smaller go left.
}elseif(key.compareTo((K) c.obj.getKey())<0){
if(c.getLeft()==null){
c.setLeft(i);
done=true;
}else{
c=c.getLeft();
}
}
}
}
}
/**
* This finds the value associated with they key. If this key c
annot be found null is returned.
* @return V the associated V value.
*/
public V get(K key){
BSTMap current= root;
if(root==null){
returnnull;
}
while(current!=null&& current.obj.getKey().equals(key)==false
){
if(key.compareTo((K) current.obj.getKey())<0){
current=current.getLeft();
}else{
current=current.getRight();
}

}
if(current==null){
returnnull;
}
if(current.obj.getKey().equals(key)){
return(V) current.obj.getValue();
}
returnnull;
}
/**
*containsKey returns boolean if the key exists in the map.
* @param key the K key value to look for
* @return boolean if it exists
*/
publicboolean containsKey(K key){
if(root==null){
returnfalse;
}
){
}else{
}
}
if(current==null){
returnfalse;
}
return current.obj.getKey().equals(key);
}
/**
* getBSTMap returns the BSTMap associated with a key val

ue
* @return BSTMap contained the K key.
*/
privateBSTMap getBSTMap(K key){
if(root==null){
returnnull;
}
){
}else{
}
}
return current;
}
returnnull;
}
/**
* remove removes the BSTMap associated with they key, an
d returns its associated value.
*
* If the key cannot be found null is returned
* @param key the K key value to be found
* @return V the value of associated with the BSTMap contai
ning the K key value.
*/
public V remove(K key){
if(root==null){
returnnull;
}elseif(root.obj.getKey().equals(key)){

System.out.println("the node to remove is the root.");
V val=(V) root.obj.getValue();
if(root.isLeaf()){
root=null;
}elseif(root.getLeft()==null){
root=root.getRight();
}elseif(root.getRight()==null){
root=root.getLeft();
}else{
root=sucessor(root);
}
return val;
}
BSTMap n= getBSTMap(key);
if(n==null){
returnnull;
}else{
set.remove(key);
V a=(V) n.obj.getValue();
BSTMap temp=null;
BSTMap child=null;
if(n.isLeaf()){
temp=n;
n=null;
}elseif(n.getLeft()!=null&& n.getLeft().getRight()==null){
temp=n;
n.getLeft().setRight(n.right);
n.setLeft(null);
}elseif(n.getRight()!=null&& n.getRight().getLeft()==null){
temp=n;
n.getRight().setLeft(n.getLeft());
n.setRight(null);
}else{
temp=sucessor(n);
n.setRight(null);

}
System.out.println("this is the temp:"+
temp.obj.key);
if(temp.getLeft()!=null){
child=temp.getLeft();
}else{
child=temp.getRight();
}if(child!=null){
child.parent=temp.parent;
}if(temp.parent.getLeft()==temp){
temp.parent.setLeft(child);
}else{
temp.parent.setRight(child);
}
return a;
}
}
privateBSTMap sucessor(BSTMap n){
boolean running=true;
BSTMap current=n.getRight();
while(running){
if(current.getLeft()!=null){
}else{
running=false;
}
}
return current;
}
/**
* keySet returns a Set of the K key values in the map.
* @return

*/
publicSet<K> keySet(){
return set;
}
}
BinaryTree.classpublicsynchronizedclass BinaryTree {
Object v;
BinaryTree treeLeft;
BinaryTree treeRight;
void BinaryTree(BinaryTree, Object, BinaryTree);
BinaryTree getLeftChild();
BinaryTree getRightChild();
void setLeftChild(BinaryTree);
void setRightChild(BinaryTree);
void setValue(Object);
Object getValue();
boolean isLeaf();
}
BinaryTree.javaBinaryTree.java
/**
* BinaryTree is a form of linked nodes that form a tree.
*
* @author tai-lan hirabayashi
*
* @param <E> the object value that is within each node.
*/
publicclassBinaryTree<E>{
E v;
BinaryTree<E> treeLeft;
BinaryTree<E> treeRight;

/**
* BinaryTree creates a new node binaryTree which holds an
object value.
* It takes in the value, left and right child and holds them wi
thin the node.
* @param left the left child of the node.
* @param value the object the node holds
* @param right the right child of the node
*/
BinaryTree(BinaryTree<E> left, E value,BinaryTree<E> right){
v=value;
treeLeft=left;
treeRight=right;
}
/**
* getLeftChild returns the left child node.
* @return the left child, a binary tree node.
*/
BinaryTree<E> getLeftChild(){
return treeLeft;
}
/**
* getRightChild returns the right child node.
* @return the right child,a binaryTree node.
*/
BinaryTree<E> getRightChild(){
return treeRight;
}
/**
* setLeftChild, sets the left child of the current node.
* @param l is the left child, a binaryTree node.
*/

void setLeftChild(BinaryTree<E> l){
treeLeft=l;
}
/**
* setRightChild, sets the right child of the current node.
* @param r the right child, a binaryTree node.
*/
void setRightChild(BinaryTree<E> r){
treeRight=r;
}
/**
* setValue sets the value of a node.
* @param object value of the node.
*/
void setValue(E object){
v=object;
}
/**
* getValue returns the value held in the node.
* @return the object value of the node.
*/
E getValue(){
return v;
}
/**
* isLeaf checks if the node is a leaf node by checking if it ha
s children.
* @return boolean if the node is a leaf node.
*/
boolean isLeaf(){
if(getLeftChild()==null&& getRightChild()==null){
returntrue;

}
returnfalse;
}
}
HuffmanTreeTest.classpublicsynchronizedclass
HuffmanTreeTest {
HuffmanTree h;
String t;
public void HuffmanTreeTest();
public void start() throws java.io.FileNotFoundException;
public void testEncode();
public void testDecode();
}
HuffmanTreeTest.javaHuffmanTreeTest.java
importstatic org.junit.Assert.*;
import java.io.File;
import java.io.FileNotFoundException;
import org.junit.Before;
import org.junit.Test;
publicclassHuffmanTreeTest{
HuffmanTree h;
String t;
/**
* start creates a test case
* @throws FileNotFoundException
*/

@Before
publicvoid start()throwsFileNotFoundException{
h =HuffmanTree.newTreeFromFile(newFile("/Users/tai-
lanhirabayashi/Desktop/test.txt"));
}
/**
* testEncode tries to encode a string.
*/
@Test
publicvoid testEncode(){
t = h.encode("This program must work!");
}
/**
* testDecode tries to decode the string.
*/
@Test
publicvoid testDecode(){
assertEquals("This program must work!", h.decode(t));
}
}
HTreeTest.classpublicsynchronizedclass HTreeTest {
HTree t;
public void HTreeTest();
public void start();
public void testGetBelow();
public void testGetF();
public void testGetS();
public void testGetL();

public void testGetR();
public void testIsLeaf();
public void testSetL();
public void testSetR();
}
HTreeTest.javaHTreeTest.javaimportstatic org.junit.Assert.*;
publicclassHTreeTest{
HTree t;
/**
* Start initializes a test case of HTree
*/
@Before
publicvoid start(){
t=newHTree(1,"one");
HTree a=newHTree(2,"two");
HTree b=newHTree(3,"three");
t.setL(a);
t.setR(b);
}
/**
* testGetBelow tests GetBelow
*/
@Test
publicvoid testGetBelow(){
assertEquals(1,t.getBelow());
assertEquals(0,t.getL().getBelow());

HTree a=newHTree(4,"a");
HTree b=newHTree(5,"b");
t.getL().setL(a);
t.getL().setR(b);
}
/**
* testGetF tests getF
*/
@Test
publicvoid testGetF(){
assertEquals(1,t.getF());
assertEquals(2,t.getL().getF());
assertEquals(3,t.getR().getF());
}
/**
* testGetS tests getS
*/
@Test
publicvoid testGetS(){
assertEquals("one",t.getS());
assertEquals("two",t.getL().getS());
assertEquals("three",t.getR().getS());
}
/**
* testGetL tests getL
*/
@Test
publicvoid testGetL(){
assertEquals(null,t.getL().getL());

}
/**
* testGetR tests getR
*/
@Test
publicvoid testGetR(){
assertEquals(null,t.getR().getR());
}
/**
* testIsLeaf tests isLeaf
*/
@Test
publicvoid testIsLeaf(){
assertEquals(false,t.isLeaf());
assertEquals(true,t.getR().isLeaf());
assertEquals(true,t.getL().isLeaf());
}
/**
* testSetL tests setL
*/
@Test
publicvoid testSetL(){
t.setL(null);
assertEquals(null,t.getL());
}
/**
* testSetR tests setR
*/
@Test

publicvoid testSetR(){
t.setR(null);
assertEquals(null,t.getR());
}
}
Heap$MaxHeapComparator.classpublicsynchronizedclass
Heap$MaxHeapComparator implements java.util.Comparator {
public void Heap$MaxHeapComparator();
public int compare(Comparable, Comparable);
}
Heap$MinHeapComparator.classpublicsynchronizedclass
Heap$MinHeapComparator implements java.util.Comparator {
public void Heap$MinHeapComparator();
}
Heap.classpublicsynchronizedclass Heap {
int s;
Object[] h;
int maxS;
java.util.Comparator c;
public void Heap(int, java.util.Comparator);
public Object findMax();
public Object removeMax();
public void insert(Object);
public int size();
private void siftUp(int);
private void siftDown(int);
}

Heap.javaHeap.javaimport java.lang.reflect.Array;
import java.util.Comparator;
import java.util.NoSuchElementException;
publicclassHeap<E>{
int s;
Object[] h;
int maxS;
Comparator c;
/**
* Heap takes in the initial size of the heap.
* @param i the integer value of the size of the heap.
*/
publicHeap(int i,Comparator<?super E> comparator){
c=comparator;
s=0;
maxS=i;
h=newObject[i];
}
/**
* findMax returns the largest item of the heap.
* If the heap is empty it will throw a noSuchElementExcepti
on.
* @return E the max object
*/
public E findMax(){
if(s==0){
System.out.println("an error has been thrown because the heap i
s empty");
thrownewNoSuchElementException();

}
return(E) h[0];
}
/**
* removeMax removes the largest item. If the list is empty a
NoSuchElementException is thrown.
* @return the max object
*/
public E removeMax(){
if(s==0){
s empty");
}
E last =(E) h[s-1];
E first =(E) h[0];
h[0]=last;
h[s-1]=null;
s--;
siftDown(0);
return first;
}
/**
* insert inserts an item into the heap and bubbles it into the
correct position.
* @param item that is inserted
*/
publicvoid insert(E item){
if(s==maxS-1){
maxS=maxS*2;
Object[] grownArray =newObject[maxS];
System.arraycopy(h,0, grownArray,0, h.length);
h=grownArray;
}
h[s]=item;
siftUp(s);

s++;
}
/**
* size returns the size of the heap.
* @return the integer size of the heap
*/
publicint size(){
return s;
}
/**
* siftUp, sifts the node at index i up through the heap into th
e correct position.
* @param i the value to begin sifting
*/
privatevoid siftUp(int i)
{
int n=i;
boolean inPlace =false;
if(n==0){
inPlace=true;
}
while(inPlace==false){
int a=(n-1)/2;
E below=(E) h[n];
E above=(E) h[a];
if(c.compare(below,above)>0){
h[n]= above;
h[a]=below;
n=a;
}else{
inPlace=true;
}

}
}
/**
* SiftDown sifts the node at index i down to the correct spot
in the heap.
*/
privatevoid siftDown(int i)
{
int n=i;
int a=(n*2)+1;
E above=(E) h[n];
E belowL=(E) h[a];
E belowR=(E) h[a+1];
if(belowL==null&& belowR==null){
return;
}
//if neither of the children are null
if(belowL !=null&& belowR !=null){
//compare to the left child
if(c.compare(above,belowL)<0&& c.compare(belowL,belowR)>
=0){
System.out.println("down and to the left!");
h[a]= above;
h[n]=belowL;
n=a;
//compare to the right child
}elseif(c.compare(above,belowR)<0){
System.out.println("down and to the right!");

h[a+1]= above;
h[n]=belowR;
n=a;
//otherwise its in place
}else{
System.out.println("its down in place");
inPlace=true;
}
//if the left child isnt null
}elseif(belowL !=null){
if(c.compare(above, belowL)<0){
h[n]= above;
h[a]=belowL;
n=a;
}else{
inPlace=true;
}
}else{
// if the right child isnt null compare it to the parent
if(c.compare(above,belowR)<0){
h[a+1]= above;
h[n]=belowR;
n=a;
}else{
inPlace=true;
}
}
}
}

/**
* MaxHeapComparator compares two values and prioritizes t
he max value.
*
* @param <E> the comparable object
*/
publicstaticclassMaxHeapComparator<E extendsComparable<E
>>implementsComparator<E>{
@Override
publicint compare(E o1, E o2){
return o1.compareTo(o2);
}
}
/**
* MinHeapComparator compares two values and prioritizes t
he lower value
*
*/
publicstaticclassMinHeapComparator<E extendsComparable<E>
>implementsComparator<E>{
@Override
return(-1* o1.compareTo(o2));
}
}
}

PriorityQueueTest.classpublicsynchronizedclass
PriorityQueueTest {
PriorityQueue p;
public void PriorityQueueTest();
public void testPeek();
public void testRemove();
public void testSize();
public void testEmpty();
}
PriorityQueueTest.javaPriorityQueueTest.javaimportstatic org.j
unit.Assert.*;
publicclassPriorityQueueTest{
PriorityQueue p;
/**
* Start initialized the program, with a queue of 1,2,3,4 and a
max priority.
*/
@Before
publicvoid start(){
Comparator<Integer> c =newHeap.MaxHeapComparator();
p=newPriorityQueue(10, c);
p.add(1);

p.add(2);
p.add(3);
p.add(4);
}
/**
* testPeek tests the peek function.
*/
@Test
publicvoid testPeek(){
assertEquals(4, p.peek());
p.remove();
p.remove();
p.remove();
p.remove();
assertEquals(null, p.peek());
}
/**
* restRemove tests the remove function.
*/
@Test
publicvoid testRemove(){
assertEquals(4, p.remove());
assertEquals(null, p.remove());
}
/**

* testSize tests the size function.
*/
@Test
publicvoid testSize(){
assertEquals(4, p.size());
p.remove();
p.remove();
p.remove();
p.remove();
p.add(9);
}
/**
* testEmpty tests the isEmpty function of priorityQueue.
*/
@Test
publicvoid testEmpty(){
assertFalse(p.isEmpty());
p.remove();
p.remove();
p.remove();
p.remove();
assertTrue(p.isEmpty());
p.add(5);
}

}
BSTMap.classpublicsynchronizedclass BSTMap extends Map {
nObject obj;
BSTMap left;
BSTMap right;
int s;
BSTMap parent;
public void BSTMap(Object, Object);
public void setParent(BSTMap);
public BSTMap getParent();
public void setLeft(BSTMap);
public void setRight(BSTMap);
public BSTMap getLeft();
public BSTMap getRight();
boolean isLeaf();
}
BSTMap.javaBSTMap.java
publicclassBSTMap<K,V>extendsMap{
nObject obj;
BSTMap<K,V> left;
BSTMap<K,V> right;
int s;
BSTMap<K,V> parent;
/**
* BSTMap creates a node with a K key and V value.
* @param ke the K value
* @param va the V value
*/
publicBSTMap(K ke, V va){
obj=new nObject(ke,va);
left=null;

right=null;
parent=null;
}
/**
* setParent sets the BSTMap which is this nodes parent.
* @param p the parent
*/
publicvoid setParent(BSTMap<K,V> p){
parent=p;
}
/**
* getParent returns the parent of this node.
* @return BSTMap that is this nodes parent.
*/
publicBSTMap<K,V> getParent(){
return parent;
}
/**
* setLeft sets the BSTMap left child.
*
* @param child BSTMap that is this nodes child.
*/
publicvoid setLeft(BSTMap<K,V> child){
left=child;
if(child!=null){
left.setParent(this);
}
}
/**
* setRight sets the this nodes BSTMap child.
*/
publicvoid setRight(BSTMap<K,V> child){

right=child;
if(child!=null){
right.setParent(this);
}
}
/**
* getLeft returns this nodes left BSTMap child.
* @return BSTMap this nodes left child
*/
publicBSTMap<K,V> getLeft(){
return left;
}
/**
* getRight returns this nodes right BSTMap child.
* @return BSTMap this nodes right child
*/
publicBSTMap<K,V> getRight(){
return right;
}
/**
s children.
*
* It returns true for leaf, false for if it has children.
*/
boolean isLeaf(){
if(getLeft()==null&& getRight()==null){
returntrue;
}
returnfalse;
}

}
BinaryTreeTest.classpublicsynchronizedclass BinaryTreeTest {
BinaryTree t;
public void BinaryTreeTest();
public void before();
public void testSetup();
public void testGetLeft();
public void testGetRight();
public void isLeaf();
public void setLeft();
public void setRight();
public void setValue();
}
BinaryTreeTest.javaBinaryTreeTest.javaimportstatic org.junit.A
ssert.*;
/**
* BinaryTreeTest tests to see if Binary Tree functions as expect
ed.
*
*/
publicclassBinaryTreeTest{
BinaryTree t;
/**
* before sets up a base case.
*/
@Before

publicvoid before(){
t=newBinaryTree(null,"head",null);
t.setLeftChild(newBinaryTree(null,"second",null));
t.getLeftChild().setLeftChild(newBinaryTree(null,"third",
null));
}
/**
* testSetup makes sure the test has been initialized.
*/
@Test
publicvoid testSetup(){
assertEquals(t.getValue(),"head");
}
/**
* tests the getLeft function
*/
@Test
publicvoid testGetLeft(){
assertEquals(t.getLeftChild().getValue(),"second");
}
/**
* Tests the get right function
*/
@Test
publicvoid testGetRight(){
assertEquals(t.getRightChild(),null);
}
/**
* Tests the isLeaf function.
*/
@Test
publicvoid isLeaf(){
assertEquals(t.getLeftChild().getLeftChild().isLeaf(),true);

}
/**
* Tests the setLeft function
*/
@Test
publicvoid setLeft(){
t.setLeftChild(newBinaryTree(null,"replace",null));
assertEquals(t.getLeftChild().getValue(),"replace");
}
/**
* tests the setRightChild function
*/
@Test
publicvoid setRight(){
t.setRightChild(newBinaryTree(null,"right",null));
assertEquals(t.getRightChild().getValue(),"right");
}
/**
* Tests the setValue function.
*/
@Test
publicvoid setValue(){
t.getLeftChild().setValue("reset");
assertEquals(t.getLeftChild().getValue(),"reset");
}
}
ArithmeticExpressionTest.classpublicsynchronizedclass
ArithmeticExpressionTest {
ArithmeticExpression a;

public void ArithmeticExpressionTest();
public void startUp() throws java.text.ParseException;
public void testExceptions();
public void testToString();
public void testEval();
public void testVar() throws java.rmi.NotBoundException,
public void testPostFix();
public void testWithoutSpaces() throws
}
ArithmeticExpressionTest.javaArithmeticExpressionTest.javaim
portstatic org.junit.Assert.*;
import java.rmi.NotBoundException;
/**
* ArithmeticExpressionTest tests the functionality of Arithmeti
cExpression.
*** Note, the Program includes postFix() which returns a postfi
x String of the equation.
*** It can also handle strings with or without spaces.
*
*
*
*/
publicclassArithmeticExpressionTest{

/**
* StartUp sets up the base case scenario.
* @throws ParseException if the equation is not valid.
*/
@Before
publicvoid startUp()throwsParseException{
a=newArithmeticExpression("3 + 4 * 2");
}
/**
* testExceptions tests the programs thrown exceptions.
*/
@Test
publicvoid testExceptions(){
boolean errorThrown =false;
try{
a=newArithmeticExpression("3 + * 2");
}catch(ParseException e){
errorThrown=true;
}
assert(errorThrown);
errorThrown=false;
try{
a.setVariable("y",2);
}catch(NotBoundException e){
errorThrown=true;
}
}
/**
* testToString tests the toString method of the ArithmeticEx
pression
*/
@Test

publicvoid testToString(){
System.out.println("this is toString: "+ a.toString(a.t));
assertEquals(a.toString(a.t),"((2*4)+3)");
}
/**
* testEval tests the evaluate method of ArithmeticExpression
*/
@Test
publicvoid testEval(){
assertEquals(a.evaluate(a.t),11);
}
/**
* testVar tests the setVariable function of ArithmeticExpress
ion
* by checking how a variable is handled.
* @throws NotBoundException
*/
@Test
publicvoid testVar()throwsNotBoundException,ParseException{
a=newArithmeticExpression("2 + 3 * x");
a.setVariable("x",2);
}
/**
* Tests the postFix() method.
*/
@Test
publicvoid testPostFix(){
assertEquals(a.toPostfixString(a.t),"3 4 2 * +");
}
@Test
publicvoid testWithoutSpaces()throwsParseException{
a=newArithmeticExpression("2+3*x");

}
}
nObject.classpublicsynchronizedclass nObject {
Object key;
Object value;
public void nObject(Object, Object);
public Object getKey();
public Object getValue();
public void changeKey(Object);
public void changeValue(Object);
}
nObject.javanObject.java
publicclass nObject<K,V>{
K key;
V value;
/**
* nObject creates a new nObject object with a K,V values he
ld.
* @param ky the K key value
* @param val the V value value.
*/
public nObject (K ky, V val){
key=ky;
value=val;
}
/**
* getKey returns the K key.
* @return K, the key
*/
public K getKey(){

return key;
}
/**
* getValue returns the V value.
* @return V value
*/
public V getValue(){
return value;
}
/**
* changeK allows the user to pass in a new K key.
* @param ky K to be changed to.
*/
publicvoid changeKey(K ky){
key=ky;
}
/**
* changeValue allows the value to be changed.
* @param val the new V value.
*/
publicvoid changeValue(V val){
value=val;
}
}
BSTMapTest.classpublicsynchronizedclass BSTMapTest {
BSTMap m;
public void BSTMapTest();
public void startUp();

public void testGetParent();
public void testSetLeft();
public void testSetRight();
public void testSetParent();
}
BSTMapTest.javaBSTMapTest.javaimportstatic org.junit.Assert
.*;
publicclassBSTMapTest{
BSTMap m;
/**
* startUp creates a new instance of BSTMap.
*/
@Before
publicvoid startUp(){
m=newBSTMap(1,"one");
}
/**
* testGetLeft tests getLeft().
*
* It tests when it doesnt exist, when it does exist, when it ha
s been changed, and when it has been removed.
*/
@Test
assertEquals(null, m.getLeft());

m.setRight(newBSTMap(3,"three"));
BSTMap child=newBSTMap(2,"two");
BSTMap a=newBSTMap(1,"a");
m.setLeft(child);
assertEquals(child, m.getLeft());
m.setLeft(a);
assertEquals(a, m.getLeft());
m.setLeft(null);
}
/**
* testGetRight tests getRight().
*
* It tests when it doesnt exist, when it does exist, and when i
t has been removed.
*/
@Test
assertEquals(null, m.getRight());
m.setLeft(newBSTMap(2,"two"));
BSTMap child =newBSTMap(3,"three");
m.setRight(child);
assertEquals(child, m.getRight());
m.setRight(a);
assertEquals(a, m.getRight());
m.setRight(null);

}
/**
* testGetParent tests getParent()
*
* It tests when there is a parent, when there is not a parent.
*/
@Test
publicvoid testGetParent(){
assertEquals(null, m.getParent());
m.setRight(child);
assertEquals(m, child.getParent());
}
/**
* testIsLeaf tests to see if a node is a leaf.
*
* It tests when it has no children, when it has a left child, a
right child, both, and when they have been removed.
*/
@Test
assertTrue(m.isLeaf());
assertFalse(m.isLeaf());
m.setLeft(null);
m.setRight(null);

}
/**
* testSetLeft tests setLeft()
*
*/
@Test
publicvoid testSetLeft(){
m.setLeft(child);
assertEquals(child,m.getLeft());
m.setLeft(null);
assertEquals(null,m.getLeft());
}
/**
* testSetRight tests setRight
*/
@Test
publicvoid testSetRight(){
assertEquals(null, a.getRight());
a.setRight(child);
assertEquals(child, a.getRight());
a.setRight(null);
}
/**

* testSetParent tests setParent
*/
@Test
publicvoid testSetParent(){
assertEquals(null, a.getParent());
a.setParent(child);
assertEquals(child, a.getParent());
a.setParent(null);
}
}
HTree.classpublicsynchronizedclass HTree {
private String s;
private int f;
HTree l;
HTree r;
public void HTree(int, String);
public void setL(HTree);
public void setR(HTree);
public HTree getL();
public HTree getR();
public String getS();
public int getF();
public boolean isLeaf();
public int getBelow();
}
HTree.javaHTree.java
publicclassHTree<E extendsComparable<E>>{

privateString s;
privateint f;
HTree l;
HTree r;
/**
* HTree creates a HTree object containing a int frequency an
d a String str.
* @param frequency the integer frequency of the str
* @param str the str value of this HTree
*/
publicHTree(int frequency,String str){
s=str;
f=frequency;
l=null;
r=null;
}
/**
* setL sets the left HTree value
* @param left the HTree that is the left child of this node
*/
publicvoid setL(HTree left){
l=left;
}
/**
* setR sets the right HTree child value
* @param right the HTree that is the right child of this node
*/
publicvoid setR(HTree right){
r=right;
}
/**

* getL returns the left child of this node.
* @return HTree the left child.
*/
publicHTree getL(){
return l;
}
/**
* getR returns the right child of this node.
* @return HTree the right child.
*/
publicHTree getR(){
return r;
}
/**
* getS returns the string value associated with this node
* @return String the value of this node
*/
publicString getS(){
return s;
}
/**
* getF returns the frequency value associated with this node.
* @return the int frequency value associated with this node.
*/
publicint getF(){
return f;
}
/**
* isLeaf returns boolean if this node is a leaf.
* @return boolean wether this node is a leaf.
*/
publicboolean isLeaf(){

if(l==null&&r==null){
returntrue;
}
returnfalse;
}
/**
* getBelow recursively finds how many children this node h
as.
*
* **this does not handle trees with only one child (as this do
es not occur in a huffmanTree)
* @return the int number height
*/
publicint getBelow(){
if(isLeaf()){
return0;
}else{
int a=1+l.getBelow();
int b=1+r.getBelow();
if(a>b){
System.out.println("returning a: "+ a);
return a;
}
System.out.println("returning b"+ b);
return b;
}
}
}
HeapTest.classpublicsynchronizedclass HeapTest {
Heap h;

Heap min;
public void HeapTest();
public void testFindMax();
public void testRemoveMax();
public void testMin();
}
HeapTest.javaHeapTest.javaimportstatic org.junit.Assert.*;
publicclassHeapTest{
Heap h;
Heap min;
/**
* start creates a test case of heap both min and max compara
tor.
*/
@Before
publicvoid start(){
Comparator<Integer> c =newHeap.MaxHeapComparator<Intege
r>();
Comparator<Integer> m =newHeap.MinHeapComparator<Intege
r>();
min=newHeap(10,m);
min.insert(1);
min.insert(2);
min.insert(3);

min.insert(4);
h=newHeap(10,c);
System.out.println("this is 1");
h.insert(1);
System.out.println(h.h[0]);
h.insert(2);
System.out.println(h.h[0]+","+h.h[1]);
h.insert(3);
System.out.println(h.h[0]+","+h.h[1]+","+h.h[2]);
h.insert(4);
System.out.println(h.h[0]+","+h.h[1]+","+h.h[2]+","+h.h[3]);
}
/**
* testFindMax tests the findMax function
*/
@Test
publicvoid testFindMax(){
assertEquals(4, h.findMax());
assertEquals(4, h.removeMax());
assertEquals(1, min.findMax());
assertEquals(1, min.removeMax());
}
/**
* testRemoveMax tests the remove max function

*/
@Test
publicvoid testRemoveMax(){
assertEquals(4,h.removeMax());
assertEquals(0,h.size());
}
/**
* testSize tests the size function of heap.
*/
@Test
assertEquals(4, h.size());
int o=(Integer) h.removeMax();
h.insert(o);
h.removeMax();
h.removeMax();
h.removeMax();
h.removeMax();
assertEquals(4, min.size());
}
/**
* testMin tests the minSort comparator.
*/

@Test
publicvoid testMin(){
assertEquals(4, min.size());
assertEquals(1,min.removeMax());
}
}
HuffmanTree$CountPair.classsynchronizedclass
HuffmanTree$CountPair {
int _count;
String _text;
private void HuffmanTree$CountPair(HuffmanTree, String,
int);
}
HuffmanTree$CountPairTreeComparator.classsynchronizedclass
HuffmanTree$CountPairTreeComparator implements
java.util.Comparator {
private void
HuffmanTree$CountPairTreeComparator(HuffmanTree);
public int compare(BinaryTree, BinaryTree);
}
HuffmanTree.classpublicsynchronizedclass HuffmanTree {
java.io.File current;
BSTMap _lookupTable;

BinaryTree _huffmanTree;
public void HuffmanTree();
publicstatic HuffmanTree newTreeFromFile(java.io.File)
throws java.io.FileNotFoundException;
publicstatic HuffmanTree
newTreeFromCompressedFile(java.io.File) throws
java.io.FileNotFoundException;
private void buildFromFile(java.io.File) throws
private void buildTreeFromMap(PriorityQueue);
private void buildFromCompressedFile(java.io.File) throws
public void saveCompressedFile(java.io.File);
public void saveExpandedFile(java.io.File);
public String encode(String);
public String decode(String);
}
HuffmanTree.javaHuffmanTree.javaimport java.io.File;
import java.util.Scanner;
import java.util.Set;
/**
* This class implements the basic functionality of Huffman co
mpression and expansion.
*
* @author C. Andrews
*
*/
publicclassHuffmanTree{
File current;
BSTMap<String,String> _lookupTable =newBSTMap<String,Str

ing>(null,null);
BinaryTree<CountPair> _huffmanTree;
/**
* This is a factory method for reading in a fresh text file to i
nitialize the Huffman tree.
*
* @param file the document to use for the code frequencies
* @return a HuffmanTree containing the Huffman codes bas
ed on the frequencies observed in the document
*/
publicstaticHuffmanTree newTreeFromFile(File file)throwsFile
NotFoundException{
HuffmanTree tree =newHuffmanTree();
tree.buildFromFile(file);
return tree;
}
/**
* This is a factory method that builds a new HuffmanTree fr
om a compressed file.
*
* @param file a file that has been compressed with a Huffma
n tool
* @return a new HuffmanTree containing the codes for deco
ding the file
*/
publicstaticHuffmanTree newTreeFromCompressedFile(File file
)throwsFileNotFoundException{
// TODO implement this
}

/**
* This method builds the Huffman tree from the input file.
*
* @param file the file to use to construct the Huffman tree
*/
privatevoid buildFromFile(File file)throwsFileNotFoundExcepti
on{
current=file;
// read file and build the map of the character frequencies
Map<String,Integer> freqMap =newBSTMap<String,Integer>();
Scanner scanner =newScanner(file);
scanner.useDelimiter("");
String character;
while(scanner.hasNext()){
character = scanner.next();
Integer count = freqMap.get(character);
if(count ==null){
count =Integer.valueOf(0);
}
freqMap.put(character, count+1);
}
// for each key, make a tree and load it into the priority queue
PriorityQueue<BinaryTree<CountPair>> treeQueue =newPriorit
yQueue<BinaryTree<CountPair>>(freqMap.keySet().size(),new
CountPairTreeComparator());
BinaryTree<CountPair> tmpTree;
for(String key: freqMap.keySet()){

int frequency = freqMap.get(key);
tmpTree =newBinaryTree<CountPair>(null,newCountPa
ir(key, frequency),null);
treeQueue.add(tmpTree);
}
// while the size of the priority queue is greater than 1, combine
the top items into a tree and put them back in the priority queue
BinaryTree<CountPair> tree1, tree2;
int newFrequency;
String newText;
while(treeQueue.size()>1){
tree1 = treeQueue.remove();
tree2 = treeQueue.remove();
// If the height of the second tree is less than the height of the fi
rst,
// or the heights are the same and tree2 precedes tree1 alphabeti
cally, swap them so
// the smaller/earlier tree is put on the left
if(tree1.getValue()._text.length()> tree2.getValue()._text.length
()
||( tree1.getValue()._text.length()== tree2.getValue()._text.lengt
h()
&& tree1.getValue()._text.compareTo(tree2.getValue()._text)>0
)){
tmpTree = tree1;
tree1 = tree2;
tree2 = tmpTree;
}
// create a new tree combining the two smaller trees, computing
a new frequency that is the sum of the
// children frequencies and a new text that is the appended comb
ination of the children's text
newFrequency = tree1.getValue()._count + tree2.getVal
ue()._count;

newText = tree1.getValue()._text + tree2.getValue()._te
xt;
tmpTree =newBinaryTree<CountPair>(tree1,newCountP
air(newText, newFrequency), tree2);
treeQueue.add(tmpTree);
}
// pull the completed tree from the priority queue
BinaryTree<CountPair> tree = treeQueue.remove();
// create map of symbols to code lengths using the tree
Map<String,Integer> codeLengthMap =newMap<String,Integer>
();
// TODO implement this part
PriorityQueue pq=newPriorityQueue(setC.size(),new treeCompa
rator());
buildTreeFromMap(pq);
}
privatevoid buildTreeFromMap(PriorityQueue q){
// TODO Auto-generated method stub
}
/**
* Builds the tree using information found in a compressed fil
e.
*
* The table is the first thing we find in the file. The first pie
ce of data is the length
* of the table (L). This is followed by L pairs of character an

d code length pairs.
*
* @param file the file to read the Huffman code from.
*/
privatevoid buildFromCompressedFile(File file)throwsFileNotF
oundException{
}
/**
* Read the original file and compress it using the Huffman cod
es, writing the result
* into the output file.
*
* @param outputFile the output file
*/
publicvoid saveCompressedFile(File outputFile){
}
/**
* Read the compressed file that initialized this object and wr
ite the decoded version out
* into the output file.
*
* @param outputFile the destination file for the uncompress
ed file.
*/
publicvoid saveExpandedFile(File outputFile){
}

/**
* This method reads in a String of text and returns a String o
f 0s and 1s corresponding to the Huffman code stored in this tre
e.
* @param text the text to be encoded
* @return a String representation of the Huffman code
*/
publicString encode(String text){
StringBuilder builder =newStringBuilder();
String tmp;
for(int i =0; i < text.length(); i++){
tmp = _lookupTable.get(String.valueOf(text.charAt(i)));
builder.append(tmp);
}
return builder.toString();
}
/**
* This method reads in a String representation of a Huffman
code corresponding to this Huffman tree and decodes it.
* @param text a String representation of the a Huffman code
d message
* @return the original text
*/
publicString decode(String text){
StringBuilder builder =newStringBuilder();
BinaryTree<CountPair> current = _huffmanTree;
for(int i =0; i < text.length(); i++){
char c = text.charAt(i);
if(c =='0'){
current = current.getLeftChild();
}elseif(c =='1'){

current = current.getRightChild();
}else{
thrownewRuntimeException("Encountered unexpected character
in coded String");
}
if(current.isLeaf()){
builder.append(current.getValue()._text);
current = _huffmanTree;
}
}
return builder.toString();
}
privateclassCountPair{
int _count;
String _text;
privateCountPair(String text,int count){
_text = text;
_count = count;
}
}
privateclassCountPairTreeComparatorimplementsComparator<B
inaryTree<CountPair>>{
@Override
publicint compare(BinaryTree<CountPair> t1,BinaryTree<Coun
tPair> t2){
CountPair p1 = t1.getValue();
CountPair p2 = t2.getValue();

if(p1._count != p2._count){
return p2._count - p1._count;
}elseif(p1._text.length()!= p2._text.length()){
return-p1._text.length()- p2._text.length();
}else{
return p1._text.compareTo(p2._text);
}
}
}
}
nObjectTest.classpublicsynchronizedclass nObjectTest {
nObject o;
public void nObjectTest();
public void setUp();
public void testChangeKey();
public void testChangeValue();
public void testGetKey();
public void testGetValue();
}
nObjectTest.javanObjectTest.javaimportstatic org.junit.Assert.*
;
import org.junit.BeforeClass;

publicclass nObjectTest {
nObject o;
/**
* setUp sets up the test.
*/
@Before
publicvoid setUp(){
o=new nObject("one",1);
}
/**
* tests the change Key function
*/
@Test
publicvoid testChangeKey(){
assertEquals("one", o.getKey());
o.changeKey("two");
assertEquals("two", o.getKey());
}
/**
* tests the change Value function
*/
@Test
publicvoid testChangeValue(){
assertEquals(1, o.getValue());
o.changeValue(2);
}
/**
* testGetKey tests the getKey method
*/
@Test
publicvoid testGetKey(){

assertEquals("one", o.getKey());
o.changeKey("two");
assertEquals("two", o.getKey());
}
/**
* testGetValue tests get Value
*/
@Test
publicvoid testGetValue(){
o.changeValue(2);
}
}
MapTest.classpublicsynchronizedclass MapTest {
Map m;
public void MapTest();
public void testContainsKey();
public void testGet();
public void testKeySet();
public void testPut();
}
MapTest.javaMapTest.javaimportstatic org.junit.Assert.*;

publicclassMapTest{
Map m;
/**
* start() creates an initial map to test.
*/
@Before
publicvoid start(){
m=newMap();
}
/**
* testContainsKey tests the containsKey function.
* It tests when there are more than one object, one object,
* when the object is contained, and when the object is not co
ntained.
*/
@Test
publicvoid testContainsKey(){
assertFalse(m.containsKey(5));
m.put(5,"five");
m.put(4,"four");
assertTrue( m.containsKey(5));
m.remove(5);
m.remove(4);
}
/**
* testGet tests the get function of map.
*

* It tests when there are no objects, when there is an object,
and when there are more than one objects.
*/
@Test
publicvoid testGet(){
assertEquals(null, m.get(5));
m.put(5,"five");
assertEquals("five",m.get(5));
m.put(4,"four");
}
/**
* testKeySet tests keySet.
*/
@Test
publicvoid testKeySet(){
assertEquals(true, m.keySet().isEmpty());
m.put(5,"five");
assertEquals(false, m.keySet().isEmpty());
assertEquals(true, m.keySet().contains(5));
}
/**
* testPut tests the put method of map.
*/
@Test
publicvoid testPut(){
assertEquals(null, m.get(5));
m.put(5,"five");
m.put(5,"changed");
m.put(6,"six");
assertEquals("changed",m.get(5));
assertEquals("six",m.get(6));

}
/**
* testRemove tests map's remove function
*
* It tests if it can remove something that isnt in map, and re
moval of objects not in order.
*/
@Test
assertEquals(null, m.remove("a"));
m.put(5,"five");
m.put(4,"four");
m.put(3,"three");
assertEquals("three", m.remove(3));
assertEquals("five", m.remove(5));
assertEquals("four", m.remove(4));
}
}
.project
assignment 8
org.eclipse.jdt.core.javabuilder

org.eclipse.jdt.core.javanature
META-INF/MANIFEST.MF
Manifest-Version: 1.0
.classpath
PriorityQueue.classpublicsynchronizedclass PriorityQueue {
Heap q;
public void PriorityQueue(int, java.util.Comparator);
public Object peek();
public Object remove();
void add(Object);
boolean isEmpty();
public int size();
}
PriorityQueue.javaPriorityQueue.javaimport java.util.Comparat
or;
publicclassPriorityQueue<E>{

Heap q;
/**
*PriorityQueue initializes the queue.
*
* @param initialCapacity an int that is the heaps initial size.
* @param comparator the priority of various imputs.
*/
publicPriorityQueue(int initialCapacity,Comparator<?super E>
comparator){
q=newHeap(initialCapacity,comparator);
}
/**
* Peek, returns the next item in the queue without removing
it.
*
* If it is empty then null is returned.
* @return the next item in the queue.
*/
public E peek(){
if(q.size()==0){
returnnull;
}
return(E) q.findMax();
}
/**
* This removes the first item from the queue.
*
* It returns null if the queue is empty.
* @return the first item in the queue.
*/
public E remove(){
if(q.size()==0){
returnnull;

}
return(E) q.removeMax();
}
/**
* This adds item to the queue
* @param item that is added to the queue.
*/
void add(E item){
q.insert(item);
}
/**
* isEmpty returns if the queue is empty or not.
*
* @return boolean if the queue is empty or not.
*/
boolean isEmpty(){
if(q.size()!=0){
returnfalse;
}
returntrue;
}
/**
* size returns the size of the queue.
*
* @return int the size of the queue.
*/
publicint size(){
return q.size();
}
}
ArithmeticExpression.classpublicsynchronizedclass

ArithmeticExpression {
BinaryTree t;
java.util.ArrayList list;
String equation;
void ArithmeticExpression(String) throws
public String toString(BinaryTree);
public String toPostfixString(BinaryTree);
void setVariable(String, int) throws
java.rmi.NotBoundException;
public int evaluate(BinaryTree);
}
ArithmeticExpression.javaArithmeticExpression.javaimport java
.rmi.NotBoundException;
import java.util.ArrayList;
import java.util.Stack;
/**
* ArithmeticExpression takes equations in the form of strings c
reates a binary
* tree, and can return either the regular or postfix equation. It a
lso allows
* them to be calculated.
*
*
* Extra Credit:
* ** it can handle spaces or no spaces in the string inputted. **
it can return
* regular or postfix notation
*
*
*/

publicclassArithmeticExpression{
BinaryTree t;
ArrayList list;
String equation;
/**
* ArithmeticExpression is the construction which takes in a
space
* delimitated equation containing "*,/,+,-
" symbols and converts it into a
* binary tree.
*
* If the expression is not valid it will throw a ParseExceptio
n. This is
* the constructor. It will take a String containing the express
ion.
*
* ** The equation can take in stings delimitated by spaces, o
r withot any
* spaces. If it contains a mix, then the non spaced part(s) wil
l be
* considered to be a variable.
*
* @param expression
* @throws ParseException
* if the string is not a valid equation
*/
@SuppressWarnings({"unchecked","rawtypes"})
ArithmeticExpression(String expression)throwsParseException{
//hold the string globally
equation = expression;
//create a new arrayList to be used globally that holds the variab
les

list =newArrayList();
//split the string
String[] s = expression.split(" ");
// create a stack of tree's and operators
Stack tree =newStack();
Stack operator =newStack();
//create the string Next
String next ="";
// if the string expression doesnt contain spaces
if(!expression.contains(" ")){
int i =0;
//if it starts with an operator throw an error this cannot be.
if(expression.charAt(0)=='+'|| expression.charAt(0)=='*'
|| expression.charAt(0)=='-'
|| expression.charAt(0)=='/'){
System.out.println("this equation starts with a operator.");
}
// if the expression ends with an operator throw an error this can
not be.
if(expression.charAt(expression.length()-1)=='+'
|| expression.charAt(expression.length()-1)=='*'
|| expression.charAt(expression.length()-1)=='-'
|| expression.charAt(expression.length()-1)=='/'){
System.out.println("this equation ends with a operator.");
thrownewParseException(expression, expression.length());
}
//go through each characer in the expression and see if its a num
ber/variable, or operator.

while(i < expression.length()){
if(expression.charAt(i)=='+'|| expression.charAt(i)=='*'
|| expression.charAt(i)=='-'
|| expression.charAt(i)=='/'){
// if the character is a operator add a space to the begining and f
ront and add it to the "next" string
String str =String.valueOf(expression.charAt(i));
next = next +" "+ str +" ";
}else{
// if its an operator add it to the end of the "next" string.
next = next + expression.charAt(i);
}
// increase i to move to the next character.
i++;
}
// split the new string with added spaces.
s = next.split(" ");
}
// if the string still doesnt exist throw the error.
if(s.length ==0){
System.out
.println("there has been an error. You have not entered a string
with any characters");
}
// make sure there arent two operators in a row.
for(int i =0; i < s.length; i++){
if(i >=1
&&(s[i].equals("+")|| s[i].equals("-")
|| s[i].equals("*")|| s[i].equals("/"))){

if(s[i -1].equals("+")|| s[i -1].equals("-")
|| s[i -1].equals("*")|| s[i -1].equals("/")){
System.out
.println("there were two operators in a row. The equation is not
valid.");
}
}
// check to make sure there arent two operands in a row in the St
ring[]
if(i >=1
&&(s[i].equals("+")==false&& s[i].equals("-")==false
&& s[i].equals("*")==false&& s[i].equals("/")==false)){
if(s[i -1].equals("+")==false
&& s[i -1].equals("-")==false
&& s[i -1].equals("*")==false
&& s[i -1].equals("/")==false){
System.out
.println("there were two operands in a row. The equation is not
valid.");
}
}
// if its a number create a new tree node, and add it to the tree st
ack
if(s[i].equals("+")==false&& s[i].equals("-")==false
&& s[i].equals("*")==false&& s[i].equals("/")==false){
BinaryTree o =newBinaryTree(null, s[i],null);
tree.add(o);
}elseif(operator.empty()|| s[i].equals("*")|| s[i].equals("/")){
//if its a * or / symbol hold it to ensure order of operation

}else{
//group the tree's together.
tree.push(n);
}
}
}
// at the end ensure that the operator is empty.
tree.push(n);
}
//if there is more than 1 tree at the end something went wrong
if(tree.size()>=2){
System.out
.println("this expression is invalid. There were more operands t
han operators.");
System.out
r");
while(tree.empty()==false){
return;

}
}
//if there are still operators there is something wrong
if(operator.empty()==false){
System.out
r.");
System.out
.println("there were too many operators in the string the progra
m cannot continue.");
{
return;
}
}
// set the tree globally
t =(BinaryTree) tree.pop();
}
/**
* toString returns the String equation of that the passed in bi
nary tree
* represents.
*
* @param tree
* that represents an equation
aryTree.
*/
@SuppressWarnings("rawtypes")
publicString toString(BinaryTree tree){

// if its a leaf return its value
}else{
//else combine each parent child combination
//call recursively, and contain each call in parenthesis.
String s =("("+ toString(tree.getLeftChild())+ tree.getValue()
+ toString(tree.getRightChild())+")");
return s;
}
}
/**
* toPostfixString returns the string containing the parsed exp
ression in
* postFix notation with spaces between numbers and operato
rs to ensure clarity.
*
* @param tree that represents an equation
aryTree in
* postfix form.
*/
publicString toPostfixString(BinaryTree tree){
//if its a leaf return its value
}else{
//otherwise call recursively down the tree
// and add the operator to the end of the two operands.
// also add spaces to allow numbers to be seen individually.
String s = toPostfixString(tree.getRightChild())+" "

+ toPostfixString(tree.getLeftChild())+" "
+ tree.getValue();
System.out.println("this is what s is "+ s);
return s;
}
}
/**
* This allows the user to set a value for a variable in the exp
ression. If
* the variable does not exist in the function, throw a NotBou
ndException.
*
* @param name of the variable
* @param value that the variable has
* @throws NotBoundException if the variable is not used in
the equation
*/
void setVariable(String name,int value)throwsNotBoundExcepti
on{
//Note var, is not a Var it is a seperate class that is an object.
//if the equation string doesnt contain the variable throw an erro
r
if(!equation.contains(name)){
thrownewNotBoundException();
}
// else continue and check if the var object is already in the list
for(int i =0; i < list.size(); i++){
var v =(var) list.get(i);
if(v.getName().equals(name)){
//if so change the value of the var object

v.setValue(value);
return;
}
}
// otherwise add the var object to the list.
list.add(new var(name, value));
}
/**
* Evaluate returns the integer result of the expression.
*
* Variables that are not declared are calculated at 0.
*
* @return the value of the equation
*/
@SuppressWarnings("unused")
publicint evaluate(BinaryTree tree){
//if it is a leaf
String s =(String) tree.getValue();
//if all characters are numbers simply skip down to return the in
teger value.
for(int i =0; i < s.length(); i++){
if(s.charAt(i)=='0'|| s.charAt(i)==('1')
|| s.charAt(i)=='8'|| s.charAt(i)=='9'){
}else{
//if there are non numeric characters check if the list has their v
alues

for(int j =0; j < list.size(); j++){
var h =(var) list.get(j);
if(h.getName().equals(s)){
return h.getValue();
}
}
//otherwise tell the user that this variable cannot be found and t
hat its value is calulated at 0
System.out.println("this variable "+ s
+" cannot be found! Its value will be 0.");
return0;
}
returnInteger.parseInt((String) tree.getValue());
}
}
//find the left and right values of the tree
int left = evaluate(tree.getLeftChild());
int right = evaluate(tree.getRightChild());
//calculate appropriately.
if(tree.getValue().equals("*")){
return left * right;
}elseif(tree.getValue().equals("/")){
return left / right;
}elseif(tree.getValue().equals("+")){
return left + right;
}
return left - right;
}

}
Map.classpublicsynchronizedclass Map {
BSTMap root;
BSTMap found;
java.util.TreeSet set;
public void Map();
public void put(Comparable, Object);
public Object get(Comparable);
public boolean containsKey(Comparable);
private BSTMap getBSTMap(Comparable);
public Object remove(Comparable);
private BSTMap sucessor(BSTMap);
public java.util.Set keySet();
}
Map.javaMap.javaimport java.util.Set;
import java.util.TreeSet;
publicclassMap<K extendsComparable<K>,V>{
BSTMap root;
BSTMap found;
TreeSet<K> set;
/**
* Map initializes the map.
*/
publicMap(){
set=newTreeSet<K>();
root=null;
found=null;

}
/**
* put loads the Key and value into a BSTMap object, and the
key into the set.
*
* If the key already exists the value is changed to the new va
lue.
* @param value the V value value
*/
publicvoid put(K key, V value){
//if the root is null this is the root
if(root==null){
root=newBSTMap(key,value);
set.add(key);
//if the key exists then change the value
}elseif(get(key)!=null){
getBSTMap(key).obj.value=value;
}else{
//otherwise create a new BSTMap
BSTMap i =newBSTMap(key,value);
//add it to the set
set.add(key);
//and find its place in the BSTmap tree.No key can be identical.
boolean done=false;
BSTMap c= root;
while(done==false){
//if it is bigger go right

if(key.compareTo((K) c.obj.getKey())>=0){
if(c.getRight()==null){
c.setRight(i);
done=true;
}else{
c=c.getRight();
}
//if it is smaller go left.
}elseif(key.compareTo((K) c.obj.getKey())<0){
if(c.getLeft()==null){
c.setLeft(i);
done=true;
}else{
c=c.getLeft();
}
}
}
}
}
/**
* This finds the value associated with they key. If this key c
annot be found null is returned.
* @return V the associated V value.
*/
public V get(K key){
if(root==null){
returnnull;
}

){
}else{
}
}
if(current==null){
returnnull;
}
return(V) current.obj.getValue();
}
returnnull;
}
/**
*containsKey returns boolean if the key exists in the map.
* @param key the K key value to look for
* @return boolean if it exists
*/
publicboolean containsKey(K key){
if(root==null){
returnfalse;
}
){
}else{
}
}
if(current==null){
returnfalse;

}
return current.obj.getKey().equals(key);
}
/**
* getBSTMap returns the BSTMap associated with a key val
ue
* @return BSTMap contained the K key.
*/
privateBSTMap getBSTMap(K key){
if(root==null){
returnnull;
}
){
}else{
}
}
return current;
}
returnnull;
}
/**
* remove removes the BSTMap associated with they key, an
d returns its associated value.
*
* If the key cannot be found null is returned
* @param key the K key value to be found
* @return V the value of associated with the BSTMap contai

ning the K key value.
*/
public V remove(K key){
if(root==null){
returnnull;
}elseif(root.obj.getKey().equals(key)){
System.out.println("the node to remove is the root.");
V val=(V) root.obj.getValue();
if(root.isLeaf()){
root=null;
}elseif(root.getLeft()==null){
root=root.getRight();
}elseif(root.getRight()==null){
root=root.getLeft();
}else{
root=sucessor(root);
}
return val;
}
BSTMap n= getBSTMap(key);
if(n==null){
returnnull;
}else{
set.remove(key);
V a=(V) n.obj.getValue();
BSTMap temp=null;
BSTMap child=null;
if(n.isLeaf()){
temp=n;
n=null;
}elseif(n.getLeft()!=null&& n.getLeft().getRight()==null){
temp=n;
n.getLeft().setRight(n.right);
n.setLeft(null);
}elseif(n.getRight()!=null&& n.getRight().getLeft()==null){

temp=n;
n.getRight().setLeft(n.getLeft());
n.setRight(null);
}else{
temp=sucessor(n);
n.setRight(null);
}
System.out.println("this is the temp:"+
temp.obj.key);
if(temp.getLeft()!=null){
child=temp.getLeft();
}else{
child=temp.getRight();
}if(child!=null){
child.parent=temp.parent;
}if(temp.parent.getLeft()==temp){
temp.parent.setLeft(child);
}else{
temp.parent.setRight(child);
}
return a;
}
}
privateBSTMap sucessor(BSTMap n){
boolean running=true;
BSTMap current=n.getRight();
while(running){
if(current.getLeft()!=null){
}else{
running=false;
}
}
return current;

}
/**
* keySet returns a Set of the K key values in the map.
* @return
*/
publicSet<K> keySet(){
return set;
}
}
BinaryTree.classpublicsynchronizedclass BinaryTree {
Object v;
BinaryTree treeLeft;
BinaryTree treeRight;
void BinaryTree(BinaryTree, Object, BinaryTree);
BinaryTree getLeftChild();
BinaryTree getRightChild();
void setLeftChild(BinaryTree);
void setRightChild(BinaryTree);
void setValue(Object);
Object getValue();
boolean isLeaf();
}
BinaryTree.javaBinaryTree.java
/**
* BinaryTree is a form of linked nodes that form a tree.
*
*
* @param <E> the object value that is within each node.

*/
publicclassBinaryTree<E>{
E v;
BinaryTree<E> treeLeft;
BinaryTree<E> treeRight;
/**
* BinaryTree creates a new node binaryTree which holds an
object value.
* It takes in the value, left and right child and holds them wi
thin the node.
* @param left the left child of the node.
* @param value the object the node holds
* @param right the right child of the node
*/
BinaryTree(BinaryTree<E> left, E value,BinaryTree<E> right){
v=value;
treeLeft=left;
treeRight=right;
}
/**
* getLeftChild returns the left child node.
* @return the left child, a binary tree node.
*/
BinaryTree<E> getLeftChild(){
return treeLeft;
}
/**
* getRightChild returns the right child node.
* @return the right child,a binaryTree node.
*/
BinaryTree<E> getRightChild(){
return treeRight;

}
/**
* setLeftChild, sets the left child of the current node.
* @param l is the left child, a binaryTree node.
*/
void setLeftChild(BinaryTree<E> l){
treeLeft=l;
}
/**
* setRightChild, sets the right child of the current node.
* @param r the right child, a binaryTree node.
*/
void setRightChild(BinaryTree<E> r){
treeRight=r;
}
/**
* setValue sets the value of a node.
* @param object value of the node.
*/
void setValue(E object){
v=object;
}
/**
* getValue returns the value held in the node.
* @return the object value of the node.
*/
E getValue(){
return v;
}
/**

s children.
*/
boolean isLeaf(){
if(getLeftChild()==null&& getRightChild()==null){
returntrue;
}
returnfalse;
}
}
HuffmanTreeTest.classpublicsynchronizedclass
HuffmanTreeTest {
HuffmanTree h;
String t;
public void HuffmanTreeTest();
public void start() throws java.io.FileNotFoundException;
public void testEncode();
public void testDecode();
}
HuffmanTreeTest.javaHuffmanTreeTest.java
importstatic org.junit.Assert.*;
import java.io.File;
publicclassHuffmanTreeTest{
HuffmanTree h;

String t;
/**
* start creates a test case
*/
@Before
publicvoid start()throwsFileNotFoundException{
h =HuffmanTree.newTreeFromFile(newFile("/Users/tai-
lanhirabayashi/Desktop/test.txt"));
}
/**
* testEncode tries to encode a string.
*/
@Test
publicvoid testEncode(){
t = h.encode("This program must work!");
}
/**
* testDecode tries to decode the string.
*/
@Test
publicvoid testDecode(){
assertEquals("This program must work!", h.decode(t));
}
}
HTreeTest.classpublicsynchronizedclass HTreeTest {
HTree t;

public void HTreeTest();
public void testGetBelow();
public void testGetF();
public void testGetS();
public void testGetL();
public void testGetR();
public void testSetL();
public void testSetR();
}
HTreeTest.javaHTreeTest.javaimportstatic org.junit.Assert.*;
publicclassHTreeTest{
HTree t;
/**
* Start initializes a test case of HTree
*/
@Before
publicvoid start(){
t=newHTree(1,"one");
HTree a=newHTree(2,"two");
HTree b=newHTree(3,"three");
t.setL(a);
t.setR(b);
}
/**

* testGetBelow tests GetBelow
*/
@Test
publicvoid testGetBelow(){
assertEquals(0,t.getL().getBelow());
HTree a=newHTree(4,"a");
HTree b=newHTree(5,"b");
t.getL().setL(a);
t.getL().setR(b);
}
/**
* testGetF tests getF
*/
@Test
publicvoid testGetF(){
assertEquals(1,t.getF());
}
/**
* testGetS tests getS
*/
@Test
publicvoid testGetS(){
assertEquals("one",t.getS());
assertEquals("two",t.getL().getS());
assertEquals("three",t.getR().getS());
}
/**

* testGetL tests getL
*/
@Test
publicvoid testGetL(){
assertEquals(null,t.getL().getL());
}
/**
* testGetR tests getR
*/
@Test
publicvoid testGetR(){
assertEquals(null,t.getR().getR());
}
/**
* testIsLeaf tests isLeaf
*/
@Test
assertEquals(false,t.isLeaf());
assertEquals(true,t.getR().isLeaf());
assertEquals(true,t.getL().isLeaf());
}
/**
* testSetL tests setL
*/
@Test
publicvoid testSetL(){
t.setL(null);

assertEquals(null,t.getL());
}
/**
* testSetR tests setR
*/
@Test
publicvoid testSetR(){
t.setR(null);
assertEquals(null,t.getR());
}
}
Heap$MaxHeapComparator.classpublicsynchronizedclass
Heap$MaxHeapComparator implements java.util.Comparator {
public void Heap$MaxHeapComparator();
}
Heap$MinHeapComparator.classpublicsynchronizedclass
Heap$MinHeapComparator implements java.util.Comparator {
public void Heap$MinHeapComparator();
}
Heap.classpublicsynchronizedclass Heap {
int s;
Object[] h;
int maxS;
java.util.Comparator c;
public void Heap(int, java.util.Comparator);
public Object findMax();

public Object removeMax();
public void insert(Object);
public int size();
private void siftUp(int);
private void siftDown(int);
}
Heap.javaHeap.javaimport java.lang.reflect.Array;
import java.util.NoSuchElementException;
publicclassHeap<E>{
int s;
Object[] h;
int maxS;
Comparator c;
/**
* Heap takes in the initial size of the heap.
* @param i the integer value of the size of the heap.
*/
publicHeap(int i,Comparator<?super E> comparator){
c=comparator;
s=0;
maxS=i;
h=newObject[i];
}
/**
* findMax returns the largest item of the heap.
* If the heap is empty it will throw a noSuchElementExcepti
on.
* @return E the max object
*/

public E findMax(){
if(s==0){
s empty");
}
return(E) h[0];
}
/**
* removeMax removes the largest item. If the list is empty a
NoSuchElementException is thrown.
* @return the max object
*/
public E removeMax(){
if(s==0){
s empty");
}
E last =(E) h[s-1];
E first =(E) h[0];
h[0]=last;
h[s-1]=null;
s--;
siftDown(0);
return first;
}
/**
* insert inserts an item into the heap and bubbles it into the
correct position.
* @param item that is inserted
*/
publicvoid insert(E item){
if(s==maxS-1){
maxS=maxS*2;

Object[] grownArray =newObject[maxS];
System.arraycopy(h,0, grownArray,0, h.length);
h=grownArray;
}
h[s]=item;
siftUp(s);
s++;
}
/**
* size returns the size of the heap.
* @return the integer size of the heap
*/
publicint size(){
return s;
}
/**
* siftUp, sifts the node at index i up through the heap into th
e correct position.
*/
privatevoid siftUp(int i)
{
int n=i;
if(n==0){
inPlace=true;
}
int a=(n-1)/2;
E below=(E) h[n];
E above=(E) h[a];
if(c.compare(below,above)>0){

h[n]= above;
h[a]=below;
n=a;
}else{
inPlace=true;
}
}
}
/**
* SiftDown sifts the node at index i down to the correct spot
in the heap.
*/
privatevoid siftDown(int i)
{
int n=i;
int a=(n*2)+1;
E above=(E) h[n];
E belowL=(E) h[a];
E belowR=(E) h[a+1];
if(belowL==null&& belowR==null){
return;
}
//if neither of the children are null
if(belowL !=null&& belowR !=null){
//compare to the left child
if(c.compare(above,belowL)<0&& c.compare(belowL,belowR)>
=0){
System.out.println("down and to the left!");
h[a]= above;

h[n]=belowL;
n=a;
//compare to the right child
}elseif(c.compare(above,belowR)<0){
System.out.println("down and to the right!");
h[a+1]= above;
h[n]=belowR;
n=a;
//otherwise its in place
}else{
System.out.println("its down in place");
inPlace=true;
}
//if the left child isnt null
}elseif(belowL !=null){
if(c.compare(above, belowL)<0){
h[n]= above;
h[a]=belowL;
n=a;
}else{
inPlace=true;
}
}else{
// if the right child isnt null compare it to the parent
if(c.compare(above,belowR)<0){
h[a+1]= above;
h[n]=belowR;
n=a;
}else{
inPlace=true;
}

}
}
}
/**
* MaxHeapComparator compares two values and prioritizes t
he max value.
*
*/
publicstaticclassMaxHeapComparator<E extendsComparable<E
>>implementsComparator<E>{
@Override
return o1.compareTo(o2);
}
}
/**
* MinHeapComparator compares two values and prioritizes t
he lower value
*
*/
publicstaticclassMinHeapComparator<E extendsComparable<E>
>implementsComparator<E>{
@Override

return(-1* o1.compareTo(o2));
}
}
}
PriorityQueueTest.classpublicsynchronizedclass
PriorityQueueTest {
PriorityQueue p;
public void PriorityQueueTest();
public void testPeek();
public void testEmpty();
}
PriorityQueueTest.javaPriorityQueueTest.javaimportstatic org.j
unit.Assert.*;
publicclassPriorityQueueTest{
PriorityQueue p;
/**
* Start initialized the program, with a queue of 1,2,3,4 and a
max priority.

*/
@Before
publicvoid start(){
Comparator<Integer> c =newHeap.MaxHeapComparator();
p=newPriorityQueue(10, c);
p.add(1);
p.add(2);
p.add(3);
p.add(4);
}
/**
* testPeek tests the peek function.
*/
@Test
publicvoid testPeek(){
p.remove();
p.remove();
p.remove();
p.remove();
assertEquals(null, p.peek());
}
/**
* restRemove tests the remove function.
*/
@Test

assertEquals(null, p.remove());
}
/**
* testSize tests the size function.
*/
@Test
p.remove();
p.remove();
p.remove();
p.remove();
p.add(9);
}
/**
* testEmpty tests the isEmpty function of priorityQueue.
*/
@Test
publicvoid testEmpty(){
p.remove();
p.remove();
p.remove();

p.remove();
assertTrue(p.isEmpty());
p.add(5);
}
}
BSTMap.classpublicsynchronizedclass BSTMap extends Map {
nObject obj;
BSTMap left;
BSTMap right;
int s;
BSTMap parent;
public void BSTMap(Object, Object);
public void setParent(BSTMap);
public BSTMap getParent();
public void setLeft(BSTMap);
public void setRight(BSTMap);
public BSTMap getLeft();
public BSTMap getRight();
boolean isLeaf();
}
BSTMap.javaBSTMap.java
publicclassBSTMap<K,V>extendsMap{
nObject obj;
BSTMap<K,V> left;
BSTMap<K,V> right;
int s;
BSTMap<K,V> parent;
/**
* BSTMap creates a node with a K key and V value.

* @param ke the K value
* @param va the V value
*/
publicBSTMap(K ke, V va){
obj=new nObject(ke,va);
left=null;
right=null;
parent=null;
}
/**
* setParent sets the BSTMap which is this nodes parent.
* @param p the parent
*/
publicvoid setParent(BSTMap<K,V> p){
parent=p;
}
/**
* getParent returns the parent of this node.
* @return BSTMap that is this nodes parent.
*/
publicBSTMap<K,V> getParent(){
return parent;
}
/**
* setLeft sets the BSTMap left child.
*
*/
publicvoid setLeft(BSTMap<K,V> child){
left=child;
if(child!=null){
left.setParent(this);
}

}
/**
* setRight sets the this nodes BSTMap child.
*/
publicvoid setRight(BSTMap<K,V> child){
right=child;
if(child!=null){
right.setParent(this);
}
}
/**
* getLeft returns this nodes left BSTMap child.
* @return BSTMap this nodes left child
*/
publicBSTMap<K,V> getLeft(){
return left;
}
/**
* getRight returns this nodes right BSTMap child.
* @return BSTMap this nodes right child
*/
publicBSTMap<K,V> getRight(){
return right;
}
/**
s children.
*
* It returns true for leaf, false for if it has children.
*/
boolean isLeaf(){

if(getLeft()==null&& getRight()==null){
returntrue;
}
returnfalse;
}
}
BinaryTreeTest.classpublicsynchronizedclass BinaryTreeTest {
BinaryTree t;
public void BinaryTreeTest();
public void before();
public void testSetup();
public void isLeaf();
public void setLeft();
public void setRight();
public void setValue();
}
BinaryTreeTest.javaBinaryTreeTest.javaimportstatic org.junit.A
ssert.*;
/**
* BinaryTreeTest tests to see if Binary Tree functions as expect
ed.
*
*/
publicclassBinaryTreeTest{

BinaryTree t;
/**
* before sets up a base case.
*/
@Before
publicvoid before(){
t=newBinaryTree(null,"head",null);
t.setLeftChild(newBinaryTree(null,"second",null));
t.getLeftChild().setLeftChild(newBinaryTree(null,"third",
null));
}
/**
* testSetup makes sure the test has been initialized.
*/
@Test
publicvoid testSetup(){
assertEquals(t.getValue(),"head");
}
/**
* tests the getLeft function
*/
@Test
assertEquals(t.getLeftChild().getValue(),"second");
}
/**
* Tests the get right function
*/
@Test
assertEquals(t.getRightChild(),null);
}

/**
* Tests the isLeaf function.
*/
@Test
publicvoid isLeaf(){
assertEquals(t.getLeftChild().getLeftChild().isLeaf(),true);
}
/**
* Tests the setLeft function
*/
@Test
publicvoid setLeft(){
t.setLeftChild(newBinaryTree(null,"replace",null));
assertEquals(t.getLeftChild().getValue(),"replace");
}
/**
* tests the setRightChild function
*/
@Test
publicvoid setRight(){
t.setRightChild(newBinaryTree(null,"right",null));
assertEquals(t.getRightChild().getValue(),"right");
}
/**
* Tests the setValue function.
*/
@Test
publicvoid setValue(){
t.getLeftChild().setValue("reset");
assertEquals(t.getLeftChild().getValue(),"reset");
}

}
ArithmeticExpressionTest.classpublicsynchronizedclass
ArithmeticExpressionTest {
public void ArithmeticExpressionTest();
public void startUp() throws java.text.ParseException;
public void testExceptions();
public void testToString();
public void testEval();
public void testVar() throws java.rmi.NotBoundException,
public void testPostFix();
public void testWithoutSpaces() throws
}
ArithmeticExpressionTest.javaArithmeticExpressionTest.javaim
portstatic org.junit.Assert.*;
import java.rmi.NotBoundException;
/**
* ArithmeticExpressionTest tests the functionality of Arithmeti
cExpression.
*** Note, the Program includes postFix() which returns a postfi
x String of the equation.
*** It can also handle strings with or without spaces.
*
*

*
*/
publicclassArithmeticExpressionTest{
/**
* StartUp sets up the base case scenario.
*/
@Before
publicvoid startUp()throwsParseException{
a=newArithmeticExpression("3 + 4 * 2");
}
/**
* testExceptions tests the programs thrown exceptions.
*/
@Test
publicvoid testExceptions(){
boolean errorThrown =false;
try{
a=newArithmeticExpression("3 + * 2");
}catch(ParseException e){
errorThrown=true;
}
errorThrown=false;
try{
a.setVariable("y",2);
}catch(NotBoundException e){
errorThrown=true;
}

}
/**
* testToString tests the toString method of the ArithmeticEx
pression
*/
@Test
publicvoid testToString(){
System.out.println("this is toString: "+ a.toString(a.t));
assertEquals(a.toString(a.t),"((2*4)+3)");
}
/**
* testEval tests the evaluate method of ArithmeticExpression
*/
@Test
publicvoid testEval(){
}
/**
* testVar tests the setVariable function of ArithmeticExpress
ion
* by checking how a variable is handled.
* @throws NotBoundException
*/
@Test
publicvoid testVar()throwsNotBoundException,ParseException{
a=newArithmeticExpression("2 + 3 * x");
a.setVariable("x",2);
}
/**
* Tests the postFix() method.
*/
@Test
publicvoid testPostFix(){

assertEquals(a.toPostfixString(a.t),"3 4 2 * +");
}
@Test
publicvoid testWithoutSpaces()throwsParseException{
a=newArithmeticExpression("2+3*x");
}
}
nObject.classpublicsynchronizedclass nObject {
Object key;
Object value;
public void nObject(Object, Object);
public Object getKey();
public Object getValue();
public void changeKey(Object);
public void changeValue(Object);
}
nObject.javanObject.java
publicclass nObject<K,V>{
K key;
V value;
/**
* nObject creates a new nObject object with a K,V values he
ld.
* @param ky the K key value
* @param val the V value value.
*/
public nObject (K ky, V val){
key=ky;
value=val;
}

/**
* getKey returns the K key.
* @return K, the key
*/
public K getKey(){
return key;
}
/**
* getValue returns the V value.
* @return V value
*/
public V getValue(){
return value;
}
/**
* changeK allows the user to pass in a new K key.
* @param ky K to be changed to.
*/
publicvoid changeKey(K ky){
key=ky;
}
/**
* changeValue allows the value to be changed.
* @param val the new V value.
*/
publicvoid changeValue(V val){
value=val;
}
}

BSTMapTest.classpublicsynchronizedclass BSTMapTest {
BSTMap m;
public void BSTMapTest();
public void startUp();
public void testGetParent();
public void testSetLeft();
public void testSetRight();
public void testSetParent();
}
BSTMapTest.javaBSTMapTest.javaimportstatic org.junit.Assert
.*;
publicclassBSTMapTest{
BSTMap m;
/**
* startUp creates a new instance of BSTMap.
*/
@Before
publicvoid startUp(){
m=newBSTMap(1,"one");
}
/**
* testGetLeft tests getLeft().
*

* It tests when it doesnt exist, when it does exist, when it ha
s been changed, and when it has been removed.
*/
@Test
m.setLeft(child);
assertEquals(child, m.getLeft());
m.setLeft(a);
assertEquals(a, m.getLeft());
m.setLeft(null);
}
/**
* testGetRight tests getRight().
*
* It tests when it doesnt exist, when it does exist, and when i
t has been removed.
*/
@Test
m.setRight(child);
assertEquals(child, m.getRight());
m.setRight(a);
assertEquals(a, m.getRight());

m.setRight(null);
}
/**
* testGetParent tests getParent()
*
* It tests when there is a parent, when there is not a parent.
*/
@Test
publicvoid testGetParent(){
m.setRight(child);
assertEquals(m, child.getParent());
}
/**
* testIsLeaf tests to see if a node is a leaf.
*
* It tests when it has no children, when it has a left child, a
right child, both, and when they have been removed.
*/
@Test

m.setLeft(null);
m.setRight(null);
}
/**
* testSetLeft tests setLeft()
*
*/
@Test
publicvoid testSetLeft(){
m.setLeft(child);
assertEquals(child,m.getLeft());
m.setLeft(null);
assertEquals(null,m.getLeft());
}
/**
* testSetRight tests setRight
*/
@Test
publicvoid testSetRight(){
a.setRight(child);

assertEquals(child, a.getRight());
a.setRight(null);
}
/**
* testSetParent tests setParent
*/
@Test
publicvoid testSetParent(){
a.setParent(child);
assertEquals(child, a.getParent());
a.setParent(null);
}
}
HTree.classpublicsynchronizedclass HTree {
private String s;
private int f;
HTree l;
HTree r;
public void HTree(int, String);
public void setL(HTree);
public void setR(HTree);
public HTree getL();
public HTree getR();
public String getS();
public int getF();
public boolean isLeaf();

public int getBelow();
}
HTree.javaHTree.java
publicclassHTree<E extendsComparable<E>>{
privateString s;
privateint f;
HTree l;
HTree r;
/**
* HTree creates a HTree object containing a int frequency an
d a String str.
* @param frequency the integer frequency of the str
* @param str the str value of this HTree
*/
publicHTree(int frequency,String str){
s=str;
f=frequency;
l=null;
r=null;
}
/**
* setL sets the left HTree value
* @param left the HTree that is the left child of this node
*/
publicvoid setL(HTree left){
l=left;
}
/**
* setR sets the right HTree child value
* @param right the HTree that is the right child of this node
*/

publicvoid setR(HTree right){
r=right;
}
/**
* getL returns the left child of this node.
* @return HTree the left child.
*/
publicHTree getL(){
return l;
}
/**
* getR returns the right child of this node.
* @return HTree the right child.
*/
publicHTree getR(){
return r;
}
/**
* getS returns the string value associated with this node
* @return String the value of this node
*/
publicString getS(){
return s;
}
/**
* getF returns the frequency value associated with this node.
* @return the int frequency value associated with this node.
*/
publicint getF(){
return f;
}

/**
* isLeaf returns boolean if this node is a leaf.
* @return boolean wether this node is a leaf.
*/
publicboolean isLeaf(){
if(l==null&&r==null){
returntrue;
}
returnfalse;
}
/**
* getBelow recursively finds how many children this node h
as.
*
* **this does not handle trees with only one child (as this do
es not occur in a huffmanTree)
* @return the int number height
*/
publicint getBelow(){
if(isLeaf()){
return0;
}else{
int a=1+l.getBelow();
int b=1+r.getBelow();
if(a>b){
System.out.println("returning a: "+ a);
return a;
}
System.out.println("returning b"+ b);
return b;
}
}

}
HeapTest.classpublicsynchronizedclass HeapTest {
Heap h;
Heap min;
public void HeapTest();
public void testFindMax();
public void testRemoveMax();
public void testMin();
}
HeapTest.javaHeapTest.javaimportstatic org.junit.Assert.*;
publicclassHeapTest{
Heap h;
Heap min;
/**
* start creates a test case of heap both min and max compara
tor.
*/
@Before
publicvoid start(){
Comparator<Integer> c =newHeap.MaxHeapComparator<Intege
r>();

Comparator<Integer> m =newHeap.MinHeapComparator<Intege
r>();
min=newHeap(10,m);
min.insert(1);
min.insert(2);
min.insert(3);
min.insert(4);
h=newHeap(10,c);
h.insert(1);
System.out.println(h.h[0]);
h.insert(2);
System.out.println(h.h[0]+","+h.h[1]);
h.insert(3);
System.out.println(h.h[0]+","+h.h[1]+","+h.h[2]);
h.insert(4);
System.out.println(h.h[0]+","+h.h[1]+","+h.h[2]+","+h.h[3]);
}
/**
* testFindMax tests the findMax function
*/
@Test
publicvoid testFindMax(){
assertEquals(4, h.removeMax());
assertEquals(1, min.removeMax());

META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx

META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx

Ähnlich wie META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx (20)

Mehr von andreecapon

Mehr von andreecapon (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

META-INFMANIFEST.MFManifest-Version 1.0.classpath.docx