added quick select algorithm

Author: marioplumbarius

README.md

@@ -35,6 +35,7 @@ gradle clean assemble
 -- [Recursive](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/MergeSortRecursive.java)  
 -- [Iterative](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/MergeSortIterative.java)
 - [Quick Sort](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/QuickSort.java)
+- [Quick Select](https://github.com/marioluan/java-sorting-algorithms/blob/master/src/main/java/io/github/marioluan/algorithms/sorting/QuickSelect.java)
 
 ## References
 - [https://www.coursera.org/learn/algorithms-part1](https://www.coursera.org/learn/algorithms-part1)

src/main/java/io/github/marioluan/algorithms/sorting/QuickSelect.java

@@ -0,0 +1,69 @@
+package io.github.marioluan.algorithms.sorting;
+
+import edu.princeton.cs.algs4.StdRandom;
+
+/**
+ * Recursive in-place, non stable implementation of quick select algorithm which
+ * solves the select problem. <br>
+ * <strong>Time complexity:</strong> O(N) on average <br>
+ * <strong>Space complexity:</strong> O(??) <br>
+ * References:
+ * <ul>
+ * <li><a>https://www.coursera.org/learn/algorithms-part1</a>.</li>
+ * <li><a>https://en.wikipedia.org/wiki/Quickselect#/media/File:Selecting_quickselect_frames.gif</a></li>
+ * </ul>
+ * 
+ * @author marioluan
+ */
+@SuppressWarnings("rawtypes")
+public final class QuickSelect extends Sortable {
+
+    /**
+     * Select the element on index k after sorting the array a.
+     * 
+     * @param a
+     * @param k
+     *            the index from a after being sorted
+     * @return returns the value of a[k] after sort
+     */
+    public static Comparable select(Comparable[] a, int k) {
+
+        /**
+         * Preserves randomness, performance guarantees.
+         * E.g.: If the array is already sorted, it would take ~ 1/2 N ^2 of
+         * compares. Since we're shuffling the array, it is extremely unlike to
+         * happen. :)
+         * <br>
+         * Conclusion: Best case and Average cases would happen \o/.
+         */
+        StdRandom.shuffle(a);
+
+        return select(a, k, 0, a.length - 1);
+    }
+
+    /**
+     * Recursively select the element on index k of array a within lo and hi
+     * bounds.
+     * 
+     * @param a
+     * @param k
+     * @param lo
+     * @param hi
+     * @return returns the value of a[k] after sort
+     */
+    private static Comparable select(Comparable[] a, int k, int lo, int hi) {
+        if (hi <= lo)
+            return a[k];
+
+        int j = QuickSort.partition(a, lo, hi);
+
+        if (j < k)
+            lo = j + 1;
+        else if (j > k)
+            hi = j - 1;
+        else
+            return a[k];
+
+        return select(a, k, lo, hi);
+    }
+}

src/test/java/io/github/marioluan/algorithms/sorting/QuiSelectTest.java

@@ -0,0 +1,86 @@
+package io.github.marioluan.algorithms.sorting;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static com.greghaskins.spectrum.Spectrum.describe;
+import static com.greghaskins.spectrum.Spectrum.beforeEach;
+import static com.greghaskins.spectrum.Spectrum.it;
+
+import java.util.Arrays;
+import java.util.Random;
+
+import org.junit.runner.RunWith;
+
+import com.greghaskins.spectrum.Spectrum;
+
+import io.github.marioluan.algorithms.test.support.SupportHelper;
+
+@SuppressWarnings("rawtypes")
+@RunWith(Spectrum.class)
+public class QuiSelectTest {
+
+    private static final Random RANDOM = new Random();
+    private Comparable[]        array  = null;
+    private Comparable[]        clone  = null;
+    private int                 n      = 0;
+    private int                 k      = -1;
+
+    {
+        describe("MergeSortRecursive", () -> {
+            describe(".select", () -> {
+
+                describe("when array is small", () -> {
+                    beforeEach(() -> {
+                        n = RANDOM.nextInt(7) + 1;
+                        array = SupportHelper.buildRandomArray(n);
+                        clone = array.clone();
+                        k = RANDOM.nextInt(n);
+                    });
+
+                    it("sorts it", () -> {
+                        assertTrue(n >= 0);
+
+                        Arrays.sort(clone);
+
+                        assertEquals(clone[k], QuickSelect.select(array, k));
+                    });
+                });
+
+                describe("when array is huge", () -> {
+                    beforeEach(() -> {
+                        n = RANDOM.nextInt((int) Math.pow(10, 6)) + 1;
+                        array = SupportHelper.buildRandomArray(n);
+                        clone = array.clone();
+                        k = RANDOM.nextInt(n);
+                    });
+
+                    it("sorts it", () -> {
+                        assertTrue(n >= 0);
+
+                        Arrays.sort(clone);
+
+                        assertEquals(clone[k], QuickSelect.select(array, k));
+                    });
+                });
+
+                describe("when array is partially sorted", () -> {
+                    beforeEach(() -> {
+                        array = new Comparable[] { 1, 2, 3, 6, 9, 5, 10, 4, 11,
+                                13, 14, 15, 16, 17, 18, 19, 20 };
+                        clone = array.clone();
+                        k = RANDOM.nextInt(array.length);
+                    });
+
+                    it("sorts it", () -> {
+                        assertTrue(n >= 0);
+
+                        Arrays.sort(clone);
+
+                        assertEquals(clone[k], QuickSelect.select(array, k));
+                    });
+                });
+
+            });
+        });
+    }
+}

src/test/java/io/github/marioluan/algorithms/sorting/QuickSortTest.java

@@ -1,8 +1,6 @@
 package io.github.marioluan.algorithms.sorting;
 
 import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNull;
 import static com.greghaskins.spectrum.Spectrum.describe;
 import static com.greghaskins.spectrum.Spectrum.beforeEach;
 import static com.greghaskins.spectrum.Spectrum.it;