MaxHeap and MinHeap code changes + added new methods

Author: Ram swaroop

src/me/ramswaroop/arrays/KLargestElements.java

@@ -36,16 +36,17 @@ public static int[] getKLargestElements(int[] a, int k) {
 
         int[] kElements = Arrays.copyOfRange(a, 0, k);
 
-        MinHeap.buildMinHeap(kElements);
+        MinHeap minHeap = new MinHeap(kElements);
+        minHeap.buildMinHeap();
 
         for (int i = k; i < a.length; i++) {
-            if (a[i] > kElements[0]) {
-                kElements[0] = a[i];
-                MinHeap.buildMinHeap(kElements);
+            if (a[i] > minHeap.findMin()) {
+                minHeap.extractMin();
+                minHeap.insert(a[i]);
             }
         }
 
-        return kElements;
+        return minHeap.getHeap();
     }
 
     public static void main(String a[]) {

src/me/ramswaroop/arrays/KthLargestElement.java

@@ -40,16 +40,16 @@ public static int getKthLargestElementNaive(int[] a, int k) {
      * @return
      */
     public static int getKthLargestElement(int[] a, int k) {
+        MaxHeap maxHeap = new MaxHeap(a);
+        maxHeap.buildMaxHeap();
         while (true) {
-            MaxHeap.buildMaxHeap(a);
             if (k == 1) break;
-
-            swap(a, 0, a.length - 1);
-            a = Arrays.copyOfRange(a, 0, a.length - 1);
+            
+            maxHeap.extractMax();
             k--;
         }
 
-        return a[0];
+        return maxHeap.findMax();
     }
 
     private static void swap(int[] a, int firstIndex, int secondIndex) {

src/me/ramswaroop/arrays/MaxInAllSubArrays.java

@@ -32,11 +32,12 @@ public static int[] maxInAllSubArraysOfSizeKNaive(int[] a, int k) {
         for (int i = 0; i <= a.length - k; i++) {
             kElements = Arrays.copyOfRange(a, i, i + k);
             /**
-             * maxHeapify() can't be used because to call maxHeapify() on i, left(i) and right (i) should 
+             * maxHeapify() can't be used because to call maxHeapify() on i because left(i) and right (i) should 
              * already satisfy the max heap property which isn't true in this case.
              */
-            MaxHeap.buildMaxHeap(kElements);
-            maxElements[i] = kElements[0];
+            MaxHeap maxHeap = new MaxHeap(kElements);
+            maxHeap.buildMaxHeap();
+            maxElements[i] = maxHeap.findMax();
         }
 
         return maxElements;

src/me/ramswaroop/arrays/MedianOfStream.java

@@ -1,7 +1,7 @@
 package me.ramswaroop.arrays;
 
-import java.util.Arrays;
-import java.util.NoSuchElementException;
+import me.ramswaroop.common.MaxHeap;
+import me.ramswaroop.common.MinHeap;
 
 /**
  * Created by IntelliJ IDEA.
@@ -12,10 +12,17 @@
  */
 public class MedianOfStream {
 
+    /**
+     * @param med
+     * @param elem
+     * @param maxHeap
+     * @param minHeap
+     * @return
+     */
     public static int getMedianOfStream(int med, int elem, MaxHeap maxHeap, MinHeap minHeap) {
 
         switch (compare(maxHeap.getSize(), minHeap.getSize())) {
-            case 0:
+            case 0: // sizes of maxHeap and minHeap are same
                 if (elem < med) {
                     maxHeap.insert(elem);
                     med = maxHeap.findMax();
@@ -24,20 +31,20 @@ public static int getMedianOfStream(int med, int elem, MaxHeap maxHeap, MinHeap
                     med = minHeap.findMin();
                 }
                 break;
-            case 1:
+            case 1: // size of maxHeap greater than minHeap
                 if (elem < med) {
-                    minHeap.insert(maxHeap.deleteMax());
+                    minHeap.insert(maxHeap.extractMax());
                     maxHeap.insert(elem);
                 } else {
                     minHeap.insert(elem);
                 }
                 med = (maxHeap.findMax() + minHeap.findMin()) / 2;
                 break;
-            case -1:
+            case -1: // size of maxHeap smaller than minHeap
                 if (elem < med) {
                     maxHeap.insert(elem);
                 } else {
-                    maxHeap.insert(minHeap.deleteMin());
+                    maxHeap.insert(minHeap.extractMin());
                     minHeap.insert(elem);
                 }
                 med = (maxHeap.findMax() + minHeap.findMin()) / 2;
@@ -48,8 +55,10 @@ public static int getMedianOfStream(int med, int elem, MaxHeap maxHeap, MinHeap
 
     static void printMedianOfStream(int[] a) {
         int m = 0;
-        MaxHeap maxHeap = new MaxHeap(12);
-        MinHeap minHeap = new MinHeap(12);
+        MaxHeap maxHeap = new MaxHeap(a);
+        MinHeap minHeap = new MinHeap(a);
+
+        // calling in a loop so at to resemble a stream
         for (int i = 0; i < a.length; i++) {
             m = getMedianOfStream(m, a[i], maxHeap, minHeap);
         }
@@ -68,250 +77,3 @@ public static void main(String a[]) {
         printMedianOfStream(new int[]{5, 15, 1, 3, 2, 8, 7, 9, 10, 6, 11, 4});
     }
 }
-
-class MinHeap {
-    /**
-     * The number of children each node has *
-     */
-    private static final int d = 2;
-    private int size;
-    private int[] heap;
-
-    /**
-     * Constructor *
-     */
-    public MinHeap(int capacity) {
-        size = 0;
-        heap = new int[capacity + 1];
-        Arrays.fill(heap, -1);
-    }
-
-    /**
-     * Function to check if heap is empty *
-     */
-    public boolean isEmpty() {
-        return size == 0;
-    }
-
-    /**
-     * Check if heap is full *
-     */
-    public boolean isFull() {
-        return size == heap.length;
-    }
-
-    /**
-     * Clear heap
-     */
-    public void makeEmpty() {
-        size = 0;
-    }
-
-    /**
-     * Function to  get index parent of i *
-     */
-    private int parent(int i) {
-        return (i - 1) / d;
-    }
-
-    /**
-     * Function to get index of k th child of i *
-     */
-    private int kthChild(int i, int k) {
-        return d * i + k;
-    }
-
-    /**
-     * Function to insert element
-     */
-    public void insert(int x) {
-        if (isFull())
-            throw new NoSuchElementException("Overflow Exception");
-        /** Percolate up **/
-        heap[size++] = x;
-        heapifyUp(size - 1);
-    }
-
-    /**
-     * Function to find least element *
-     */
-    public int findMin() {
-        if (size == 0) return -1;
-        return heap[0];
-    }
-
-    /**
-     * Function to delete min element *
-     */
-    public int deleteMin() {
-        int keyItem = heap[0];
-        delete(0);
-        return keyItem;
-    }
-
-    /**
-     * Function to delete element at an index *
-     */
-    public int delete(int ind) {
-        if (isEmpty())
-            throw new NoSuchElementException("Underflow Exception");
-        int keyItem = heap[ind];
-        heap[ind] = heap[size - 1];
-        size--;
-        heapifyDown(ind);
-        return keyItem;
-    }
-
-    /**
-     * Function heapifyUp  *
-     */
-    private void heapifyUp(int childInd) {
-        int tmp = heap[childInd];
-        while (childInd > 0 && tmp < heap[parent(childInd)]) {
-            heap[childInd] = heap[parent(childInd)];
-            childInd = parent(childInd);
-        }
-        heap[childInd] = tmp;
-    }
-
-    /**
-     * Function heapifyDown *
-     */
-    private void heapifyDown(int ind) {
-        int child;
-        int tmp = heap[ind];
-        while (kthChild(ind, 1) < size) {
-            child = minChild(ind);
-            if (heap[child] < tmp)
-                heap[ind] = heap[child];
-            else
-                break;
-            ind = child;
-        }
-        heap[ind] = tmp;
-    }
-
-    /**
-     * Function to get smallest child *
-     */
-    private int minChild(int ind) {
-        int bestChild = kthChild(ind, 1);
-        int k = 2;
-        int pos = kthChild(ind, k);
-        while ((k <= d) && (pos < size)) {
-            if (heap[pos] < heap[bestChild])
-                bestChild = pos;
-            pos = kthChild(ind, k++);
-        }
-        return bestChild;
-    }
-
-    public int getSize() {
-        return size;
-    }
-
-    /**
-     * Function to print heap *
-     */
-    public void printHeap() {
-        System.out.print("\nHeap = ");
-        for (int i = 0; i < size; i++)
-            System.out.print(heap[i] + " ");
-        System.out.println();
-    }
-}
-
-class MaxHeap {
-    private int[] heap;
-    private int size;
-    private int maxsize;
-
-    private static final int FRONT = 1;
-
-    public MaxHeap(int maxsize) {
-        this.maxsize = maxsize;
-        this.size = 0;
-        heap = new int[this.maxsize + 1];
-        heap[0] = Integer.MAX_VALUE;
-    }
-
-    public int findMax() {
-        if (size == 0) return -1;
-        return heap[FRONT];
-    }
-
-    public int parent(int pos) {
-        return pos / 2;
-    }
-
-    private int leftChild(int pos) {
-        return (2 * pos);
-    }
-
-    private int rightChild(int pos) {
-        return (2 * pos) + 1;
-    }
-
-    private boolean isLeaf(int pos) {
-        if (pos >= (size / 2) && pos <= size) {
-            return true;
-        }
-        return false;
-    }
-
-    private void swap(int fpos, int spos) {
-        int tmp;
-        tmp = heap[fpos];
-        heap[fpos] = heap[spos];
-        heap[spos] = tmp;
-    }
-
-    private void maxHeapify(int pos) {
-        if (!isLeaf(pos)) {
-            if (heap[pos] < heap[leftChild(pos)] || heap[pos] < heap[rightChild(pos)]) {
-                if (heap[leftChild(pos)] > heap[rightChild(pos)]) {
-                    swap(pos, leftChild(pos));
-                    maxHeapify(leftChild(pos));
-                } else {
-                    swap(pos, rightChild(pos));
-                    maxHeapify(rightChild(pos));
-                }
-            }
-        }
-    }
-
-    public void insert(int element) {
-        heap[++size] = element;
-        int current = size;
-
-        while (heap[current] > heap[parent(current)]) {
-            swap(current, parent(current));
-            current = parent(current);
-        }
-    }
-
-    public int getSize() {
-        return size;
-    }
-
-    public void print() {
-        for (int i = 1; i <= size / 2; i++) {
-            System.out.print(" PARENT : " + heap[i] + " LEFT CHILD : " + heap[2 * i]
-                    + " RIGHT CHILD :" + heap[2 * i + 1]);
-            System.out.println();
-        }
-    }
-
-    public void maxHeap() {
-        for (int pos = (size / 2); pos >= 1; pos--) {
-            maxHeapify(pos);
-        }
-    }
-
-    public int deleteMax() {
-        int popped = heap[FRONT];
-        heap[FRONT] = heap[size--];
-        maxHeapify(FRONT);
-        return popped;
-    }
-}