Solve Problem 324 - WiggleSort II

Author: Hieu Luong

src/Main.java

@@ -1,8 +1,8 @@
-import bit.Problem_BitWiseANDofNumbersRange;
+import quickselect.Problem324_WiggleSortII;
 
 public class Main {
 
     public static void main(String[] args) {
-        Problem_BitWiseANDofNumbersRange.run();
+        Problem324_WiggleSortII.run();
     }
 }

src/backtrack/Problem1307_VerbalArithmeticPuzzle.java

@@ -24,7 +24,7 @@ public boolean isSolvable(String[] words, String result) {
         if (m == 0 && n == 0) return true;
         if (m*n == 0) return false;
 
-        Arrays.fill(memo, -1);
+        Array.fill(memo, -1);
         return backtrack(words, result, 0, 0, n-1, 0);
     }
 

src/binarysearch/ReadMe.java

@@ -51,7 +51,7 @@ public class ReadMe {
      *
      *
      * Collections.binarySearch
-     * Arrays.binarySearch
+     * Array.binarySearch
      * for binarySearch, the result can be negative. If key is not present, then it returns "(-(insertion point) - 1)".
      * The insertion point is defined as the point at which the key would be inserted into the list.
      *

src/dp/decision_making/Problem198_HouseRobber.java

@@ -31,7 +31,7 @@ public int rob(int[] nums) {
         // return rob_top_down(nums, n-1);
 
         // int[] memo = new int[n];
-        // Arrays.fill(memo, -1);
+        // Array.fill(memo, -1);
         // return rob_top_down_memo(nums, n-1, memo);
 
         return rob_iterative_bottom_up_dp(nums);

src/lib/Array.java

@@ -0,0 +1,56 @@
+package lib;
+
+import java.util.Random;
+
+public class Array {
+
+    public static void swap(int[] A, int i, int j) {
+        if (i == j) return;
+        int tmp = A[i];
+        A[i] = A[j];
+        A[j] = tmp;
+    }
+
+    public static void shuffle(int[] A) {
+        Random random = new Random();
+        // Attention: Reverse loop
+        for (int i = A.length-1; i >= 0; i--) {
+            swap(A, i, random.nextInt(i+1));
+        }
+    }
+
+    public static int findKthLargest(int[] A, int k) {
+        int lo = 0, hi = A.length-1; k = A.length-k;
+        // without suffle: O(N) best case / O(N^2) worst case running time + O(1) memory
+        // with suffle: the probability O(N) is rare (1/N!), O(1) memory
+        shuffle(A);
+        while (true) {
+            int pivot = quickselect(A, lo, hi);
+            if (pivot == k) break;
+            if (pivot < k) lo = pivot+1;
+            else hi = pivot-1;
+        }
+        return A[k];
+    }
+
+    public static int quickselect(int[] A, int lo, int hi) {
+        int pivot = lo; // choose the pivot at lo
+        while (true) {
+            while (lo <= hi && A[lo] <= A[pivot]) lo++;
+            while (lo <= hi && A[hi] > A[pivot]) hi--;
+            if (lo > hi) break;
+            swap(A, lo, hi);
+        }
+        swap(A, hi, pivot);
+        return hi;
+    }
+
+    public static void dutchNationalFlag(int[] A, int mid) {
+        int i = 0, j = 0, k = A.length;
+        while (j < k) {
+            if (A[j] < mid) swap(A, i++, j++);
+            else if (A[j] > mid) swap(A, j, --k);
+            else j++;
+        }
+    }
+}

src/lib/Printer.java

@@ -0,0 +1,44 @@
+package lib;
+
+public class Printer {
+
+    public static void print(int[] A) {
+        print(A, " ");
+    }
+
+    public static void print(int[] A, String separate) {
+        for (int a : A)
+            print(a, separate);
+    }
+
+    public static void print(int a) {
+        print(a, "");
+    }
+
+    public static void print(int a, String s) {
+        System.out.print(a + s);
+    }
+
+    public static void newLine() {
+        System.out.println();
+    }
+
+    public static void println(int a) {
+        println(a, "");
+    }
+
+    public static void println(int a, String s) {
+        System.out.println(a + s);
+    }
+
+    public static void println(int[] A) {
+        print(A);
+        newLine();
+    }
+
+    public static void println(int[] A, String separate) {
+        for (int a : A)
+            print(a, separate);
+        newLine();
+    }
+}

src/quickselect/Problem324_WiggleSortII.java

@@ -0,0 +1,25 @@
+package quickselect;
+
+import lib.Array;
+import lib.Printer;
+
+import java.util.Arrays;
+
+public class Problem324_WiggleSortII {
+
+    public void wiggleSort(int[] A) {
+        int n = A.length, m = (n+1) >> 1;
+        int[] copy = Arrays.copyOf(A, n);
+        int mid = Array.findKthLargest(copy, m);
+        Array.dutchNationalFlag(copy, mid);
+        for (int i = m - 1, j = 0; i >= 0; i--, j += 2) A[j] = copy[i];
+        for (int i = n - 1, j = 1; i >= m; i--, j += 2) A[j] = copy[i];
+    }
+
+    public static void run() {
+        Problem324_WiggleSortII solution = new Problem324_WiggleSortII();
+        int[] A = {2,3,3,2,2,2,1,1};
+        solution.wiggleSort(A);
+        Printer.print(A);
+    }
+}