format

Author: William Fiset

slides/dynamicprogramming/weighted_maximum_cardinality_matching.key

@@ -2,56 +2,56 @@
 
 public class QuickSelect {
 
-    public Integer quickSelect(int[] ar, int k) {
-        if (ar == null) return null;
-        if (k > ar.length) return null;
-        if (k < 1) return null;
-        return quickSelect(ar, k, 0, ar.length - 1);
-    }
+  public Integer quickSelect(int[] ar, int k) {
+    if (ar == null) return null;
+    if (k > ar.length) return null;
+    if (k < 1) return null;
+    return quickSelect(ar, k, 0, ar.length - 1);
+  }
 
-    // Sort interval [lo, hi] inplace recursively, returns value when splitPoint == k - 1
-    private static Integer quickSelect(int[] ar, int k, int lo, int hi) {
-        int index = k - 1;
-        if (lo < hi) {
-            int splitPoint = partition(ar, lo, hi);
-            if (splitPoint == index) {
-                return ar[splitPoint];
-            } else if (splitPoint > index) {
-                return quickSelect(ar, k, lo, splitPoint);
-            }
-            return quickSelect(ar, k, splitPoint + 1, hi);
-        }
-        return ar[lo];
+  // Sort interval [lo, hi] inplace recursively, returns value when splitPoint == k - 1
+  private static Integer quickSelect(int[] ar, int k, int lo, int hi) {
+    int index = k - 1;
+    if (lo < hi) {
+      int splitPoint = partition(ar, lo, hi);
+      if (splitPoint == index) {
+        return ar[splitPoint];
+      } else if (splitPoint > index) {
+        return quickSelect(ar, k, lo, splitPoint);
+      }
+      return quickSelect(ar, k, splitPoint + 1, hi);
     }
+    return ar[lo];
+  }
 
-    // Performs Hoare partition algorithm for quick select, taken from QuickSelect implementation
-    private static int partition(int[] ar, int lo, int hi) {
-        int pivot = ar[lo];
-        int i = lo - 1, j = hi + 1;
-        while (true) {
-            do {
-                i++;
-            } while (ar[i] < pivot);
-            do {
-                j--;
-            } while (ar[j] > pivot);
-            if (i < j) swap(ar, i, j);
-            else return j;
-        }
+  // Performs Hoare partition algorithm for quick select, taken from QuickSelect implementation
+  private static int partition(int[] ar, int lo, int hi) {
+    int pivot = ar[lo];
+    int i = lo - 1, j = hi + 1;
+    while (true) {
+      do {
+        i++;
+      } while (ar[i] < pivot);
+      do {
+        j--;
+      } while (ar[j] > pivot);
+      if (i < j) swap(ar, i, j);
+      else return j;
     }
+  }
 
-    // Swap two elements
-    private static void swap(int[] ar, int i, int j) {
-        int tmp = ar[i];
-        ar[i] = ar[j];
-        ar[j] = tmp;
-    }
+  // Swap two elements
+  private static void swap(int[] ar, int i, int j) {
+    int tmp = ar[i];
+    ar[i] = ar[j];
+    ar[j] = tmp;
+  }
 
-    public static void main(String[] args) {
-        QuickSelect quickSelect = new QuickSelect();
-        int[] array = {-10, 4, 6, 4, 8, -13, 1, 3};
-        int kthLargestElement = quickSelect.quickSelect(array, 3);
-        // Prints: 1
-        System.out.println(kthLargestElement);
-    }
+  public static void main(String[] args) {
+    QuickSelect quickSelect = new QuickSelect();
+    int[] array = {-10, 4, 6, 4, 8, -13, 1, 3};
+    int kthLargestElement = quickSelect.quickSelect(array, 3);
+    // Prints: 1
+    System.out.println(kthLargestElement);
+  }
 }

src/main/java/com/williamfiset/algorithms/sorting/QuickSelect.java

@@ -1,31 +1,30 @@
 package com.williamfiset.algorithms.sorting;
 
-import com.williamfiset.algorithms.utils.TestUtils;
-import org.junit.Test;
+import static com.google.common.truth.Truth.assertThat;
 
+import com.williamfiset.algorithms.utils.TestUtils;
 import java.util.Arrays;
-
-import static com.google.common.truth.Truth.assertThat;
+import org.junit.Test;
 
 public class QuickSelectTest {
 
-    @Test
-    public void testQuickSelect() {
-        for (int size = 1; size < 500; size++) {
-            // Given
-            QuickSelect quickSelect = new QuickSelect();
-            int[] values = TestUtils.randomIntegerArray(size, -100, 100);
+  @Test
+  public void testQuickSelect() {
+    for (int size = 1; size < 500; size++) {
+      // Given
+      QuickSelect quickSelect = new QuickSelect();
+      int[] values = TestUtils.randomIntegerArray(size, -100, 100);
 
-            for (int k = 1; k <= size; k++) {
-                int[] copy = values.clone();
-                Arrays.sort(values);
+      for (int k = 1; k <= size; k++) {
+        int[] copy = values.clone();
+        Arrays.sort(values);
 
-                // When
-                int kthLargestElement = quickSelect.quickSelect(copy, k);
+        // When
+        int kthLargestElement = quickSelect.quickSelect(copy, k);
 
-                // Then
-                assertThat(kthLargestElement).isEqualTo(values[k - 1]);
-            }
-        }
+        // Then
+        assertThat(kthLargestElement).isEqualTo(values[k - 1]);
+      }
     }
+  }
 }