Added Nth Smallest number (some test cases pending)

Author: rampatra

src/main/java/com/rampatra/arrays/NthSmallestNumber.java

@@ -0,0 +1,47 @@
+package com.rampatra.arrays;
+
+/**
+ * A Google Interview Question. For a simpler version of this question see {@link SmallestAndSecondSmallest}.
+ *
+ * @author rampatra
+ * @since 2019-02-01
+ */
+public class NthSmallestNumber {
+
+    private static int findNthSmallestNumber(int[] arr, int n, int start, int end) {
+        if (arr.length == 0 || arr.length < n) {
+            return -1;
+        }
+        int temp;
+        for (int i = start; i < end; i++) {
+            if (arr[i] < arr[end]) {
+                temp = arr[i];
+                arr[i] = arr[start];
+                arr[start] = temp;
+                start++;
+            }
+        }
+        temp = arr[end];
+        arr[end] = arr[start];
+        arr[start] = temp;
+
+        if (start + 1 < n) {
+            return findNthSmallestNumber(arr, n, 0, start);
+        } else if (start + 1 > n) {
+            return findNthSmallestNumber(arr, n, start + 1, end);
+        } else {
+            return arr[start];
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println(findNthSmallestNumber(new int[]{}, 3, 0, 5));
+        System.out.println(findNthSmallestNumber(new int[]{0, 1}, 3, 0, 1));
+        System.out.println(findNthSmallestNumber(new int[]{0, 1}, 2, 0, 1));
+        System.out.println(findNthSmallestNumber(new int[]{1, 0}, 2, 0, 1));
+        System.out.println(findNthSmallestNumber(new int[]{2, 3, 5, 10, 9, 4}, 3, 0, 5));
+        System.out.println(findNthSmallestNumber(new int[]{2, 3, 4, 10, 9, 4}, 3, 0, 5));
+        System.out.println(findNthSmallestNumber(new int[]{4, 8, 1, 9, 10, 2, 7, 3, 2, 6}, 3, 0, 9));
+//        System.out.println(findNthSmallestNumber(new int[]{4, 4, 4, 4, 4, 4}, 3, 0, 5));
+    }
+}

src/main/java/com/rampatra/arrays/SmallestAndSecondSmallest.java

@@ -7,11 +7,10 @@
  *
  * @author rampatra
  * @since 7/30/15
- * @time: 11:13 PM
  */
 public class SmallestAndSecondSmallest {
 
-    public static int[] getSmallestAndSecondSmallest(int[] a) {
+    private static int[] getSmallestAndSecondSmallest(int[] a) {
         int smallest = Integer.MAX_VALUE, secondSmallest = Integer.MAX_VALUE;
 
         for (int i = 0; i < a.length; i++) {
@@ -26,7 +25,7 @@ public static int[] getSmallestAndSecondSmallest(int[] a) {
         return new int[]{smallest, secondSmallest};
     }
 
-    public static void main(String a[]) {
+    public static void main(String[] a) {
         System.out.println(Arrays.toString(getSmallestAndSecondSmallest(new int[]{100, 1, 60, -10, -80, 85, 70, -80})));
         System.out.println(Arrays.toString(getSmallestAndSecondSmallest(new int[]{100, 1, 60, 10, 80, 85, 70, 0})));
     }

src/main/java/com/rampatra/sorting/QuickSort.java

@@ -3,12 +3,10 @@
 import java.util.Arrays;
 
 /**
- * Created by IntelliJ IDEA.
+ * The basic Quick Sort. See http://www.csanimated.com/animation.php?t=Quicksort to learn more.
  *
  * @author rampatra
  * @since 7/21/15
- * @time: 4:12 PM
- * @see: http://www.csanimated.com/animation.php?t=Quicksort
  */
 public class QuickSort {
 
@@ -18,32 +16,30 @@ public class QuickSort {
      * pivot element to its right and finally places the pivot element
      * at its correct position.
      *
-     * @param ar
+     * @param arr
      * @param startIndex
      * @param endIndex
      * @return position of the pivot element
      */
-    public static int partition(int[] ar, int startIndex, int endIndex) {
+    public static int partition(int[] arr, int startIndex, int endIndex) {
         int pivot = endIndex, temp;
 
         for (int i = startIndex; i < endIndex; i++) {
-            /**
-             * if ith element is smaller than pivot element then
-             * swap it with the last larger element known
-             */
-            if (ar[i] < ar[pivot]) {
+            // if ith element is smaller than pivot element then 
+            // swap it with the last larger element known
+            if (arr[i] < arr[pivot]) {
                 // swap a[startIndex] with a[i]
-                temp = ar[startIndex];
-                ar[startIndex] = ar[i];
-                ar[i] = temp;
+                temp = arr[startIndex];
+                arr[startIndex] = arr[i];
+                arr[i] = temp;
                 startIndex++;
             }
         }
 
         // place the pivot element in its correct position
-        temp = ar[startIndex];
-        ar[startIndex] = ar[pivot];
-        ar[pivot] = temp;
+        temp = arr[startIndex];
+        arr[startIndex] = arr[pivot];
+        arr[pivot] = temp;
 
         return startIndex;
     }
@@ -57,31 +53,52 @@ public static int partition(int[] ar, int startIndex, int endIndex) {
      * Best Case:   O(nlogn)
      * Worst Case:  O(n*n)
      *
-     * @param ar
+     * @param arr
      * @param startIndex
      * @param endIndex
      */
-    public static void quickSort(int[] ar, int startIndex, int endIndex) {
+    public static void quickSort(int[] arr, int startIndex, int endIndex) {
         if (startIndex < endIndex) {
-            int partition = partition(ar, startIndex, endIndex);
-            quickSort(ar, startIndex, partition - 1);
-            quickSort(ar, partition + 1, endIndex);
+            int partition = partition(arr, startIndex, endIndex);
+            quickSort(arr, startIndex, partition - 1);
+            quickSort(arr, partition + 1, endIndex);
         }
     }
 
     /**
      * Wrapper method to quick sort the entire array.
      *
-     * @param a
+     * @param arr the input array to sort
      */
-    public static void quickSort(int[] a) {
-        quickSort(a, 0, a.length - 1);
+    public static void quickSort(int[] arr) {
+        quickSort(arr, 0, arr.length - 1);
     }
 
-    public static void main(String a[]) {
+    public static void main(String[] a) {
         int[] ar = {3, 2, 1, 6, 4, 9, 7, 8};
         System.out.println(Arrays.toString(ar));
         quickSort(ar);
         System.out.println(Arrays.toString(ar));
+        
+        System.out.println("------");
+        
+        ar = new int[]{3, 2, 6, 8, 4, 3, 7, 8};
+        System.out.println(Arrays.toString(ar));
+        quickSort(ar);
+        System.out.println(Arrays.toString(ar));
+        
+        System.out.println("------");
+        
+        ar = new int[]{4, 4, 4, 4, 4, 4, 4};
+        System.out.println(Arrays.toString(ar));
+        quickSort(ar);
+        System.out.println(Arrays.toString(ar));
+        
+        System.out.println("------");
+        
+        ar = new int[]{};
+        System.out.println(Arrays.toString(ar));
+        quickSort(ar);
+        System.out.println(Arrays.toString(ar));
     }
 }