PriorityQueue

still working it out.

Author: codelogicws

out/production/Algorithms/ws/codelogic/algorithms/debug/Debug.class

@@ -0,0 +1,10 @@
+package ws.codelogic.algorithms.debug;
+
+public class Debug {
+
+    public static void printArray(int[] array){
+        for(Comparable c : array){
+            System.out.print(c + ", ");
+        }
+    }
+}

out/production/Algorithms/ws/codelogic/algorithms/priorityqueue/BinaryTree.class

@@ -1,21 +1,61 @@
 package ws.codelogic.algorithms.priorityqueue;
 
-public class BinaryTree <T>{
+public class BinaryTree{
 
-    private T[] elements;
-    private int currentElement;
+    private Comparable[] elements;
+    private int indexOfLastElement;
 
-    public BinaryTree(T[] emptyArray){
+    public BinaryTree(Comparable[] emptyArray){
         elements = emptyArray;
-        currentElement = -1;
+        indexOfLastElement = -1;
     }
 
-    public void add(T element){
-        elements[++currentElement] = element;
+    public void add(Comparable element){
+        elements[++indexOfLastElement] = element;
+        swim(indexOfLastElement);
     }
 
-    public T remove(){
-        return elements[currentElement--];
+    private void swim(int index) {
+        if(parentIsLess(index)){
+            //DEBUG
+            System.out.println("debug-BinaryTree: need to swap " + index + " and " + parrentIndex(index));
+            //DEBUG
+//                swapWithParent(index);
+//                swim(indexOfParent(index));
+        }
+    }
+
+    private boolean parentIsLess(int index){
+        if(hasParent(index)){
+            int parrentIndex = parrentIndex(index);
+            if(less(parrentIndex, index)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private int parrentIndex(int index) {
+        int treeIndex = index + 1;
+        int parrentTreeIndex = treeIndex/2;
+        return parrentTreeIndex -1;
+    }
+
+
+    private boolean less(int index1, int index2) {
+        return (elements[index1].compareTo(elements[index2]) < 0);
+    }
+
+    private boolean hasParent(int index) {
+        return index > 0;
+    }
+
+    private int indexOfParent(int currentIndex){
+        return currentIndex/2;
+    }
+
+    public Comparable remove(){
+        return elements[indexOfLastElement--];
     }
 
 

out/production/Algorithms/ws/codelogic/algorithms/priorityqueue/PriorityQueueTest.class

@@ -6,12 +6,12 @@
 
 public class PriorityQueueTest {
 
-    private BinaryTree<Integer> queue;
+    private BinaryTree queue;
 
     @Before
     public void setUp() {
         Integer[] array = new Integer[5];
-        queue = new BinaryTree<Integer>(array);
+        queue = new BinaryTree(array);
     }
 
     @Test
@@ -21,18 +21,23 @@ public void adding1ObjectYeildsThatObject() {
     }
 
     private void checkNumber(Integer numberToTest){
-        Integer numberFromQueue = queue.remove();
+        Integer numberFromQueue = (Integer)queue.remove();
         assertEquals(numberFromQueue, numberToTest);
     }
 
     @Test
     public void adding3ObjectYeildsThoseObjectsInOrder() {
         queue.add(5);
-        queue.add(1);
+        queue.add(7);
         queue.add(9);
         checkNumber(9);
         checkNumber(5);
         checkNumber(1);
     }
 
+
+
+    //array is full
+    //array is empty
+
 }