QuickSort

fixed

Author: codelogicws

out/production/Algorithms/ws/codelogic/algorithms/sort/QuickSort.class

@@ -1,60 +1,44 @@
 package ws.codelogic.algorithms.sort;
 
-import ws.codelogic.algorithms.shuffle.Shuffler;
+public class QuickSort {
 
-public class QuickSort extends Sort{
+    private static Comparable temp;
 
-    private Comparable temp;
-
-    public QuickSort(Comparable[] array){
-        this.array = array;
-    }
-
-    @Override
-    public void sort() {
-//        Shuffler shuffler = new Shuffler();
-//        array = shuffler.shuffle(array);
-        //DEBUG
-        for(Comparable c : array){
-            System.out.println(c + ", ");
-        }
-        //DEBUG
-        recursiveSort(0, array.length-1);
+    public static void sort(Comparable[] a){
+        sort(a, 0, a.length -1);
     }
 
-    private void recursiveSort(int low, int high){
-        int mid = partitioning(low, high);
-        if(low < mid-1){
-            recursiveSort(low, mid-1);
-        }
-        if(mid+1 < high){
-            recursiveSort(mid + 1, high);
-        }
+    private static void sort(Comparable[] a, int lo, int hi){
+        if(hi <= lo) return;
+        int j = partition(a, lo, hi);
+        sort(a, lo, j-1);
+        sort(a, j+1, hi);
     }
 
-    public int partitioning(int low, int high){
-        int pivot = low;
-        high++;
+    private static int partition(Comparable[] a, int lo, int hi){
+        int i = lo, j = hi+1;
+        while(true){
+            while(less(a[++i], a[lo]))
+                if(i == hi) break;
+            while(less(a[lo], a[--j]))
+                if(j == lo) break;
 
-        while(low<=high) {
-            while (less(array[++low], array[pivot])) ;
-            while (less(array[pivot], array[--high])) ;
-            swap(low, high);
+            if(i >= j) break;
+            exch(a, i, j);
         }
-        swap(pivot, high);
-        return high;
+
+        exch(a, lo, j);
+        return j;
     }
 
-    private void swap(int low, int high) {
-        if(low<high){
-            temp = array[low];
-            array[low] = array[high];
-            array[high] = temp;
-        }
+    private static boolean less(Comparable less, Comparable more){
+        return less.compareTo(more) < 0;
     }
 
-    private boolean less(Comparable less, Comparable more){
-        return less.compareTo(more) == -1;
+    private static void exch(Comparable[] array, int first, int second){
+        temp = array[first];
+        array[first] = array[second];
+        array[second] = temp;
     }
 
 }

out/production/Algorithms/ws/codelogic/algorithms/sort/QuickSortTest.class

@@ -6,20 +6,39 @@
 
 public class QuickSortTest {
 
-    private Sort quickSort;
-    private Integer[] unsorted = {5,4,3,6,7,2,1,5,9};
-    private Integer[] sorted = {1,2,3,4,5,5,6,7,9};
+    private QuickSort quickSort;
 
     @Before
     public void setup() {
-        quickSort = new QuickSort(unsorted);
+        quickSort = new QuickSort();
     }
 
     @Test
     public void testSortedOrder() {
-        quickSort.sort();
-        assertEquals(unsorted, sorted);
+        Integer[] unsorted = {9,8,4,3,6,7,2,1,5};
+        Integer[] sorted = {1,2,3,4,5,6,7,8,9};
+        test(unsorted, sorted);
+    }
+
+    @Test
+    public void testSortingWithDuplicates() {
+        Integer[] unsorted = {9,8,4,3,6,7,2,1,5,4,6,7};
+        Integer[] sorted = {1,2,3,4,4,5,6,6,7,7,8,9};
+        test(unsorted, sorted);
+    }
+
+    @Test
+    public void testSortingEdgeCase1() {
+        Integer[] unsorted = {1,6,5,4,8,9};
+        Integer[] sorted = {1,4,5,6,8,9};
+        test(unsorted, sorted);
+    }
+
+    private void test(Integer[] unsorted, Integer[] sorted){
+        quickSort.sort(unsorted);
+        Integer[] newlySorted = unsorted;
+        assertEquals(newlySorted, sorted);
     }
 
     //TODO need to test for duplicate keys
-}
+}