code refactoring

Author: Ram swaroop

src/me/ramswaroop/arrays/KthLargestElement.java

@@ -44,14 +44,20 @@ public static int getKthLargestElement(int[] a, int k) {
             MaxHeap.buildMaxHeap(a);
             if (k == 1) break;
 
-            MaxHeap.swap(a, 0, a.length - 1);
+            swap(a, 0, a.length - 1);
             a = Arrays.copyOfRange(a, 0, a.length - 1);
             k--;
         }
 
         return a[0];
     }
 
+    private static void swap(int[] a, int firstIndex, int secondIndex) {
+        a[firstIndex] = a[firstIndex] + a[secondIndex];
+        a[secondIndex] = a[firstIndex] - a[secondIndex];
+        a[firstIndex] = a[firstIndex] - a[secondIndex];
+    }
+
     public static void main(String a[]) {
         int[] ar = new int[]{2, 4, 5, 7, 1, 8, 9};
         System.out.println(Arrays.toString(ar));

src/me/ramswaroop/arrays/sorting/HeapSort.java

@@ -24,11 +24,47 @@ public static void heapSort(int[] a) {
         MaxHeap.buildMaxHeap(a);
 
         for (int i = a.length - 1; i > 0; i--) {
-            MaxHeap.swap(a, 0, i);
-            MaxHeap.maxHeapify(a, 0, i);
+            swap(a, 0, i);
+            maxHeapify(a, 0, i);
         }
     }
 
+    /**
+     * Makes the array {@param a} satisfy the max heap property starting from
+     * {@param index} till {@param end} position in array.
+     * <p/>
+     * See this {@link MaxHeap#maxHeapify} for a basic version of maxHeapify.
+     * <p/>
+     * Time complexity: O(log n).
+     *
+     * @param a
+     * @param index
+     * @param end
+     */
+    private static void maxHeapify(int[] a, int index, int end) {
+        int largest = index;
+        int leftIndex = 2 * index + 1;
+        int rightIndex = 2 * index + 2;
+
+        if (leftIndex < end && a[index] < a[leftIndex]) {
+            largest = leftIndex;
+        }
+        if (rightIndex < end && a[largest] < a[rightIndex]) {
+            largest = rightIndex;
+        }
+
+        if (largest != index) {
+            swap(a, index, largest);
+            maxHeapify(a, largest, end);
+        }
+    }
+
+    private static void swap(int[] a, int firstIndex, int secondIndex) {
+        a[firstIndex] = a[firstIndex] + a[secondIndex];
+        a[secondIndex] = a[firstIndex] - a[secondIndex];
+        a[firstIndex] = a[firstIndex] - a[secondIndex];
+    }
+
     public static void main(String a[]) {
         int[] ar = new int[]{2, 5, 1, 7, 9, 4};
         System.out.println(Arrays.toString(ar));

src/me/ramswaroop/common/MaxHeap.java

@@ -29,40 +29,29 @@ public class MaxHeap {
      * Makes the array {@param a} satisfy the max heap property starting from
      * {@param index} till the end of array.
      * <p/>
-     * Time complexity: O(log n).
-     *
-     * @param a
-     * @param index
-     */
-    public static void maxHeapify(int[] a, int index) {
-        maxHeapify(a, index, a.length);
-    }
-
-    /**
-     * Makes the array {@param a} satisfy the max heap property starting from
-     * {@param index} till {@param l} position in array.
+     * See {@link me.ramswaroop.arrays.sorting.HeapSort#maxHeapify} for a modified
+     * version of maxHeapify.
      * <p/>
      * Time complexity: O(log n).
      *
      * @param a
      * @param index
-     * @param l
      */
-    public static void maxHeapify(int[] a, int index, int l) {
+    public static void maxHeapify(int[] a, int index) {
         int largest = index;
         int leftIndex = 2 * index + 1;
         int rightIndex = 2 * index + 2;
 
-        if (leftIndex < l && a[index] < a[leftIndex]) {
+        if (leftIndex < a.length && a[index] < a[leftIndex]) {
             largest = leftIndex;
         }
-        if (rightIndex < l && a[largest] < a[rightIndex]) {
+        if (rightIndex < a.length && a[largest] < a[rightIndex]) {
             largest = rightIndex;
         }
 
         if (largest != index) {
             swap(a, index, largest);
-            maxHeapify(a, largest, l);
+            maxHeapify(a, largest);
         }
     }
 
@@ -79,7 +68,7 @@ public static void buildMaxHeap(int[] a) {
         }
     }
 
-    public static void swap(int[] a, int firstIndex, int secondIndex) {
+    private static void swap(int[] a, int firstIndex, int secondIndex) {
         a[firstIndex] = a[firstIndex] + a[secondIndex];
         a[secondIndex] = a[firstIndex] - a[secondIndex];
         a[firstIndex] = a[firstIndex] - a[secondIndex];

src/me/ramswaroop/common/MinHeap.java

@@ -35,33 +35,20 @@ public class MinHeap {
      * @param index
      */
     public static void minHeapify(int[] a, int index) {
-        minHeapify(a, index, a.length);
-    }
-
-    /**
-     * Makes the array {@param a} satisfy the min heap property starting from
-     * {@param index} till {@param l} position in array.
-     * <p/>
-     * Time complexity: O(log n).
-     *
-     * @param a
-     * @param index
-     */
-    public static void minHeapify(int[] a, int index, int l) {
         int smallest = index;
         int leftIndex = 2 * index + 1;
         int rightIndex = 2 * index + 2;
 
-        if (leftIndex < l && a[index] > a[leftIndex]) {
+        if (leftIndex < a.length && a[index] > a[leftIndex]) {
             smallest = leftIndex;
         }
-        if (rightIndex < l && a[smallest] > a[rightIndex]) {
+        if (rightIndex < a.length && a[smallest] > a[rightIndex]) {
             smallest = rightIndex;
         }
 
         if (smallest != index) {
             swap(a, index, smallest);
-            minHeapify(a, smallest, l);
+            minHeapify(a, smallest);
         }
     }