assignment 5

src/assn05/BinaryHeap.java

@@ -0,0 +1,37 @@
+package assn05;
+
+
+public interface BinaryHeap<V,P extends Comparable<P>> {
+    /**
+     * Returns number of elements in heap
+     * @return numbers of elements in heap
+     */
+    int size();
+
+    /**
+     * Create new hospital.Prioritized object and insert it into the heap
+     * @param value
+     * @param priority
+     */
+    void enqueue(V value, P priority);
+
+    /**
+     * Remove the element with the smallest priority from the heap
+     * and return its value
+     * @return the value of the removed element
+     */
+    V dequeue();
+
+    /**
+     * return the largest value in the heap without removing it
+     * @return the largest value in the heap
+     */
+    V getMax();
+
+
+    /**
+     * Retrieves contents of heap as an array.
+     * @return array of hospital.Prioritized objects in the order stored in the heap
+     */
+    Prioritized<V,P>[] getAsArray();
+}

src/assn05/Main.java

@@ -0,0 +1,194 @@
+package assn05;
+
+public class Main {
+
+    public static void main(String[] args) {
+        testP1();
+        testP2();
+        testP3();
+        testP4();
+    }
+
+    // test Part 1
+    public static void testP1() {
+        System.out.println("\nSimpleEmergencyRoom Tests (Part 1)...");
+
+        // add patients
+        SimpleEmergencyRoom simplePQ = new SimpleEmergencyRoom();
+        simplePQ.addPatient("Patient 1", 1);
+        simplePQ.addPatient("Patient 2", 2);
+        simplePQ.addPatient("Patient 3", 3);
+        simplePQ.addPatient("Patient 4", 4);
+        simplePQ.addPatient("Patient 99", 99);
+        simplePQ.addPatient("Patient 5", 5);
+        simplePQ.addPatient("Patient 6", 6);
+        simplePQ.addPatient("Patient 7", 7);
+        simplePQ.addPatient("Patient 8", 8);
+        simplePQ.addPatient("Patient 9", 9);
+        simplePQ.addPatient("Patient -1", -1);
+        simplePQ.addPatient("Patient 0", 0);
+
+        int size = simplePQ.size();
+        System.out.println("Size: " + size);
+
+        // dequeue patients
+        System.out.println("Dequeueing patients...");
+        for (int i = 0; i < size; i++) {
+            System.out.println("Dequeued " + simplePQ.dequeue().getValue());
+        }
+
+        System.out.println("SimpleEmergencyRoom Tests Complete");
+    }
+
+    // test Part 2
+    public static void testP2() {
+        System.out.println("\nMaxBinHeapER Tests (Part 2)...");
+
+        // add patients
+        MaxBinHeapER<String, Integer> binHeap = new MaxBinHeapER<String, Integer>();
+        binHeap.enqueue("Patient 1", 1);
+        binHeap.enqueue("Patient 2", 2);
+        binHeap.enqueue("Patient 3", 3);
+        binHeap.enqueue("Patient 4", 4);
+        binHeap.enqueue("Patient 99", 99);
+        binHeap.enqueue("Patient 5", 5);
+        binHeap.enqueue("Patient 6", 6);
+        binHeap.enqueue("Patient 7", 7);
+        binHeap.enqueue("Patient 8", 8);
+        binHeap.enqueue("Patient 9", 9);
+        binHeap.enqueue("Patient -1", -1);
+        binHeap.enqueue("Patient 0", 0);
+
+        int size = binHeap.size();
+        System.out.println("Size: " + size);
+
+        String max = binHeap.getMax();
+        System.out.println("Max: " + max);
+
+        Prioritized<String, Integer>[] inOrder = binHeap.getAsArray();
+        System.out.print("Array: [");
+        for (int i = 0; i < size; i++) {
+            System.out.print((inOrder[i].getPriority()) + (i < size - 1 ? ", " : ""));
+        }
+        System.out.println("]");
+
+        // dequeue patients
+        System.out.println("Dequeueing patients...");
+        for (int i = 0; i < size; i++) {
+            System.out.println("Dequeued " + binHeap.dequeue());
+        }
+
+        System.out.println("MaxBinHeapER Tests Complete");
+    }
+
+    /*
+     * Part 3
+     */
+    public static void testP3() {
+        System.out.println("\nER Transfer Tests (Part 3)...");
+
+        MaxBinHeapER<String, Integer> transfer = new MaxBinHeapER<String, Integer>();
+        transfer.enqueue("Patient 1", 1);
+        transfer.enqueue("Patient 2", 2);
+        transfer.enqueue("Patient 3", 3);
+        transfer.enqueue("Patient 4", 4);
+        transfer.enqueue("Patient 99", 99);
+        transfer.enqueue("Patient 5", 5);
+        transfer.enqueue("Patient 6", 6);
+        transfer.enqueue("Patient 7", 7);
+        transfer.enqueue("Patient 8", 8);
+        transfer.enqueue("Patient 9", 9);
+        transfer.enqueue("Patient -1", -1);
+        transfer.enqueue("Patient 0", 0);
+
+        System.out.println("Transferring patients...");
+        MaxBinHeapER<String, Integer> postTransfer = new MaxBinHeapER<String, Integer>(transfer.getAsArray());
+
+        int size = postTransfer.size();
+        System.out.println("Size: " + size);
+
+        Prioritized<String, Integer>[] inOrder = postTransfer.getAsArray();
+        System.out.print("Array: [");
+        for (int i = 0; i < size; i++) {
+            System.out.print((inOrder[i].getPriority()) + (i < size - 1 ? ", " : ""));
+        }
+        System.out.println("]");
+
+        System.out.println("ER Transfer Tests Complete");
+    }
+
+    /*
+     * Part 4
+     */
+    public static void testP4() {
+        System.out.println("\nER Transfer Tests (Part 3)...");
+        double[] results = compareRuntimes();
+
+        System.out
+                .println("\nSimpleEmergencyRoom dequeue time: " + results[0] + " ns");
+        System.out.println("SimpleEmergencyRoom dequeue time: "
+                + results[0] / 1000000 + " ms");
+        System.out.println("SimpleEmergencyRoom average dequeue time per patient: "
+                + results[1] + " ns");
+
+        System.out.println("\nMaxBinHeapER dequeue time: " + results[2] + " ns");
+        System.out.println("MaxBinHeapER dequeue time: " + results[2] / 1000000
+                + " ms");
+        System.out.println("MaxBinHeapER average dequeue time per patient: "
+                + results[3] + " ns");
+
+        System.out.println("\nER Transfer Tests Complete");
+    }
+
+    public static void fillER(MaxBinHeapER complexER) {
+        for (int i = 0; i < 100000; i++) {
+            complexER.enqueue(i);
+        }
+    }
+
+    public static void fillER(SimpleEmergencyRoom simpleER) {
+        for (int i = 0; i < 100000; i++) {
+            simpleER.addPatient(i);
+        }
+    }
+
+    public static Patient[] makePatients() {
+        Patient[] patients = new Patient[10];
+        for (int i = 0; i < 10; i++) {
+            patients[i] = new Patient(i);
+        }
+        return patients;
+    }
+
+    public static double[] compareRuntimes() {
+        // Array which you will populate as part of Part 4
+        double[] results = new double[4];
+
+        SimpleEmergencyRoom simplePQ = new SimpleEmergencyRoom();
+        fillER(simplePQ);
+
+        int origSize = simplePQ.size();
+        long currentTime = System.nanoTime();
+
+        for (int i = 0; i < origSize; i++)
+            simplePQ.dequeue();
+
+        results[0] = System.nanoTime() - currentTime;
+        results[1] = results[0] / origSize;
+
+        MaxBinHeapER binHeap = new MaxBinHeapER();
+        fillER(binHeap);
+
+        origSize = binHeap.size();
+        currentTime = System.nanoTime();
+
+        for (int i = 0; i < origSize; i++)
+            binHeap.dequeue();
+
+        results[2] = System.nanoTime() - currentTime;
+        results[3] = results[2] / origSize;
+
+        return results;
+    }
+
+}

src/assn05/MaxBinHeapER.java

@@ -0,0 +1,153 @@
+package assn05;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MaxBinHeapER<V, P extends Comparable<P>> implements BinaryHeap<V, P> {
+
+    private List<Prioritized<V, P>> _heap;
+
+    /**
+     * Constructor that creates an empty heap of hospital.Prioritized objects.
+     */
+    public MaxBinHeapER() {
+        _heap = new ArrayList<>();
+    }
+
+    /**
+     * Constructor that builds a heap given an initial array of hospital.Prioritized
+     * objects.
+     */
+    public MaxBinHeapER(Prioritized<V, P>[] initialEntries) {
+        _heap = new ArrayList<>();
+
+        for (Prioritized<V, P> entry : initialEntries)
+            _heap.add(entry);
+
+        for (int i = size() - 1; i >= 0; i--)
+            bubbleDown(i);
+    }
+
+    @Override
+    public int size() {
+        return _heap.size();
+    }
+
+    @Override
+    public void enqueue(V value, P priority) {
+        Prioritized<V, P> newEntry = new Patient(value, priority);
+        _heap.add(_heap.size(), newEntry);
+        bubbleUp(_heap.size() - 1);
+    }
+
+    public void enqueue(V value) {
+        Prioritized<V, P> newEntry = new Patient(value);
+        _heap.add(_heap.size(), newEntry);
+        bubbleUp(_heap.size() - 1);
+    }
+
+    @Override
+    public V dequeue() {
+        if (size() == 0)
+            return null;
+
+        Prioritized<V, P> max = _heap.get(0);
+        _heap.set(0, _heap.get(size() - 1));
+        _heap.remove(size() - 1);
+        bubbleDown(0);
+
+        return max.getValue();
+    }
+
+    @Override
+    public V getMax() {
+        if (size() == 0)
+            return null;
+
+        return _heap.get(0).getValue();
+    }
+
+    @Override
+    public Prioritized<V, P>[] getAsArray() {
+        Prioritized<V, P>[] result = (Prioritized<V, P>[]) Array.newInstance(Prioritized.class, size());
+        return _heap.toArray(result);
+    }
+
+    private int bubbleUp(int index) {
+        if (index == 0)
+            return index;
+
+        Prioritized<V, P> child = _heap.get(index);
+        Prioritized<V, P> parent = _heap.get(parentIndex(index));
+
+        if (child.getPriority().compareTo(parent.getPriority()) > 0) {
+            _heap.set(parentIndex(index), child);
+            _heap.set(index, parent);
+            return bubbleUp(parentIndex(index));
+        } else {
+            return index;
+        }
+    }
+
+    private void bubbleDown(int index) {
+        if (index >= size())
+            return;
+
+        Prioritized<V, P> parent = _heap.get(index);
+
+        if (!hasLeftChild(index) && !hasRightChild(index))
+            return;
+
+        if (!hasRightChild(index)) {
+            Prioritized<V, P> leftChild = _heap.get(leftChildIndex(index));
+
+            if (leftChild.getPriority().compareTo(parent.getPriority()) > 0) {
+                _heap.set(leftChildIndex(index), parent);
+                _heap.set(index, leftChild);
+                bubbleDown(leftChildIndex(index));
+            }
+        } else {
+            Prioritized<V, P> leftChild = _heap.get(leftChildIndex(index));
+            Prioritized<V, P> rightChild = _heap.get(rightChildIndex(index));
+
+            if (leftChild.getPriority().compareTo(rightChild.getPriority()) > 0) {
+                if (leftChild.getPriority().compareTo(parent.getPriority()) > 0) {
+                    _heap.set(leftChildIndex(index), parent);
+                    _heap.set(index, leftChild);
+                    bubbleDown(leftChildIndex(index));
+                }
+            } else {
+                if (rightChild.getPriority().compareTo(parent.getPriority()) > 0) {
+                    _heap.set(rightChildIndex(index), parent);
+                    _heap.set(index, rightChild);
+                    bubbleDown(rightChildIndex(index));
+                }
+            }
+        }
+    }
+
+    private boolean hasLeftChild(int index) {
+        return validIndex(leftChildIndex(index));
+    }
+
+    private boolean hasRightChild(int index) {
+        return validIndex(rightChildIndex(index));
+    }
+
+    static int leftChildIndex(int index) {
+        return 2 * index + 1;
+    }
+
+    static int rightChildIndex(int index) {
+        return 2 * index + 2;
+    }
+
+    static int parentIndex(int index) {
+        return (index - 1) / 2;
+    }
+
+    private boolean validIndex(int index) {
+        return index >= 0 && index < size();
+    }
+}

src/assn05/Patient.java

@@ -0,0 +1,38 @@
+package assn05;
+
+import java.util.Random;
+
+public class Patient<V, Integer extends Comparable<Integer>> implements Prioritized<V, Integer> {
+    private Integer priority;
+    private V value;
+
+    public Patient(V value, Integer priority) {
+        this.value = value;
+        this.priority = priority;
+    }
+
+    public Patient(V value) {
+        this.value = value;
+        calculatePriority();
+    }
+
+    @Override
+    public V getValue() {
+        return value;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return priority;
+    }
+
+    private void calculatePriority() {
+        Random random = new Random();
+        this.priority = (Integer) new java.lang.Integer(random.nextInt(1000000));
+    }
+
+    @Override
+    public int compareTo(Prioritized<V, Integer> other) {
+        return this.priority.compareTo(other.getPriority());
+    }
+}

src/assn05/Prioritized.java

@@ -0,0 +1,7 @@
+package assn05;
+
+public interface Prioritized<V,P extends Comparable<P>> {
+    V getValue();
+    P getPriority();
+    int compareTo(Prioritized<V, P> other);
+}

src/assn05/SimpleEmergencyRoom.java

@@ -0,0 +1,49 @@
+package assn05;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SimpleEmergencyRoom {
+    private List<Patient> patients;
+
+    public SimpleEmergencyRoom() {
+        patients = new ArrayList<>();
+    }
+
+    public Patient dequeue() {
+        if (patients.size() == 0)
+            return null;
+
+        Integer maxPriority = java.lang.Integer.MIN_VALUE;
+        int maxIndex = 0;
+
+        for (int i = 0; i < patients.size(); i++) {
+            Comparable<Integer> priority = patients.get(i).getPriority();
+            if (priority.compareTo(maxPriority) > 0) {
+                maxPriority = (Integer) priority;
+                maxIndex = i;
+            }
+        }
+
+        return patients.remove(maxIndex);
+    }
+
+    public <V, P> void addPatient(V value, P priority) {
+        Patient patient = new Patient(value, (Integer) priority);
+        patients.add(patient);
+    }
+
+    public <V> void addPatient(V value) {
+        Patient patient = new Patient(value);
+        patients.add(patient);
+    }
+
+    public List getPatients() {
+        return patients;
+    }
+
+    public int size() {
+        return patients.size();
+    }
+
+}