Choose the QuickSelect pivot by median of three

partition took its pivot from a fixed position, arr[lo]. On an ordered range that
is the smallest element, so each partition strips one element instead of about
half, and select becomes quadratic. At 16k elements it costs 100,667,391
comparisons where 32,727 suffice.

Using the median of arr[lo], the middle and arr[hi] makes an ordered range the
best case rather than the worst, since the middle element of an ordered range is
its true median. It also leaves arr[hi] >= the pivot, which bounds the ascending
scan, so both scans drop their per-element bound check.

No caller reaches the quadratic case today: every one passes an array read out of
a hash table, and theta indexes slots by the low bits of the hash, which are
independent of its magnitude. Feeding a union gadget strictly ascending hashes
still yields a table whose ascending-adjacent-pair fraction is 0.51. The exposure
is QuickSelect being public API, where ordered input is unremarkable, and a
compact ordered sketch's hashes are sorted.

Speed on the library's own inputs is unchanged either way, within 6% in both
directions depending on how full the hash table is.

The existing tests all shuffle before asserting, so ordered input was never
covered. They now also run ascending, descending and all-equal input, plus a
large ordered array under a time limit, which is the only way the quadratic path
can be caught given it returns the correct value.

Author: davecromberge

src/main/java/org/apache/datasketches/common/QuickSelect.java

@@ -107,20 +107,14 @@ public static long selectExcludingZeros(final long[] arr, final int nonZeros, fi
    * @return the next partition value.  Ultimately, the desired pivot.
    */
   private static int partition(final long[] arr, final int lo, final int hi) {
-    int i = lo, j = hi + 1; //left and right scan indices
+    medianOfThreeToLo(arr, lo, hi);
+    int i = lo, j = hi; //left and right scan indices
     final long v = arr[lo]; //partitioning item value
     while (true) {
       //Scan right, scan left, check for scan complete, and exchange
-      while (arr[ ++i] < v) {
-        if (i == hi) {
-          break;
-        }
-      }
-      while (v < arr[ --j]) {
-        if (j == lo) {
-          break;
-        }
-      }
+      //arr[hi] >= v and arr[lo] == v bound the scans
+      while (arr[ ++i] < v) { }
+      while (v < arr[ --j]) { }
       if (i >= j) {
         break;
       }
@@ -135,6 +129,21 @@ private static int partition(final long[] arr, final int lo, final int hi) {
     return j;
   }
 
+  //A pivot taken from a fixed position is quadratic on ordered input; a median of three is not.
+  private static void medianOfThreeToLo(final long[] arr, final int lo, final int hi) {
+    final int mid = lo + ((hi - lo) >>> 1);
+    if (arr[mid] < arr[lo]) { swap(arr, mid, lo); }
+    if (arr[hi] < arr[lo]) { swap(arr, hi, lo); }
+    if (arr[hi] < arr[mid]) { swap(arr, hi, mid); }
+    swap(arr, lo, mid);
+  }
+
+  private static void swap(final long[] arr, final int i, final int j) {
+    final long x = arr[i];
+    arr[i] = arr[j];
+    arr[j] = x;
+  }
+
   //For double arrays
 
   /**
@@ -211,20 +220,14 @@ public static double selectExcludingZeros(final double[] arr, final int nonZeros
    * @return the next partition value.  Ultimately, the desired pivot.
    */
   private static int partition(final double[] arr, final int lo, final int hi) {
-    int i = lo, j = hi + 1; //left and right scan indices
+    medianOfThreeToLo(arr, lo, hi);
+    int i = lo, j = hi; //left and right scan indices
     final double v = arr[lo]; //partitioning item value
     while (true) {
       //Scan right, scan left, check for scan complete, and exchange
-      while (arr[ ++i] < v) {
-        if (i == hi) {
-          break;
-        }
-      }
-      while (v < arr[ --j]) {
-        if (j == lo) {
-          break;
-        }
-      }
+      //arr[hi] >= v and arr[lo] == v bound the scans
+      while (arr[ ++i] < v) { }
+      while (v < arr[ --j]) { }
       if (i >= j) {
         break;
       }
@@ -239,4 +242,18 @@ private static int partition(final double[] arr, final int lo, final int hi) {
     return j;
   }
 
+  private static void medianOfThreeToLo(final double[] arr, final int lo, final int hi) {
+    final int mid = lo + ((hi - lo) >>> 1);
+    if (arr[mid] < arr[lo]) { swap(arr, mid, lo); }
+    if (arr[hi] < arr[lo]) { swap(arr, hi, lo); }
+    if (arr[hi] < arr[mid]) { swap(arr, hi, mid); }
+    swap(arr, lo, mid);
+  }
+
+  private static void swap(final double[] arr, final int i, final int j) {
+    final double x = arr[i];
+    arr[i] = arr[j];
+    arr[j] = x;
+  }
+
 }

src/test/java/org/apache/datasketches/thetacommon/QuickSelectTest.java

@@ -53,9 +53,29 @@ public void checkQuickSelect0Based() {
         final long retVal = select(arr, 0, len - 1, pivot);
         Assert.assertEquals(retVal, trueVal);
       }
+      Assert.assertEquals(select(ascending(len), 0, len - 1, pivot), trueVal);
+      Assert.assertEquals(select(descending(len), 0, len - 1, pivot), trueVal);
     }
   }
 
+  @Test
+  public void checkQuickSelect0BasedAllEqual() {
+    final int len = 64;
+    for (int pivot = 0; pivot < len; pivot++ ) {
+      final long[] arr = new long[len];
+      java.util.Arrays.fill(arr, 7L);
+      Assert.assertEquals(select(arr, 0, len - 1, pivot), 7L);
+    }
+  }
+
+  //Quadratic work still returns the right value, so only the time limit can fail here.
+  @Test(timeOut = 10_000)
+  public void checkOrderedInputIsNotQuadratic() {
+    final int len = 1 << 19;
+    Assert.assertEquals(select(ascending(len), 0, len - 1, len / 2), len / 2);
+    Assert.assertEquals(select(descending(len), 0, len - 1, len / 2), len / 2);
+  }
+
   @Test
   public void checkQuickSelect1BasedExcludingZeros() {
     final int len = 64;
@@ -116,9 +136,28 @@ public void checkQuickSelectDbl0Based() {
         final double retVal = select(arr, 0, len - 1, pivot);
         Assert.assertEquals(retVal, trueVal, 0.0);
       }
+      Assert.assertEquals(select(ascendingDbl(len), 0, len - 1, pivot), trueVal, 0.0);
+      Assert.assertEquals(select(descendingDbl(len), 0, len - 1, pivot), trueVal, 0.0);
     }
   }
 
+  @Test
+  public void checkQuickSelectDbl0BasedAllEqual() {
+    final int len = 64;
+    for (int pivot = 0; pivot < len; pivot++ ) {
+      final double[] arr = new double[len];
+      java.util.Arrays.fill(arr, 7.0);
+      Assert.assertEquals(select(arr, 0, len - 1, pivot), 7.0, 0.0);
+    }
+  }
+
+  @Test(timeOut = 10_000)
+  public void checkOrderedInputIsNotQuadraticDbl() {
+    final int len = 1 << 19;
+    Assert.assertEquals(select(ascendingDbl(len), 0, len - 1, len / 2), len / 2, 0.0);
+    Assert.assertEquals(select(descendingDbl(len), 0, len - 1, len / 2), len / 2, 0.0);
+  }
+
   @Test
   public void checkQuickSelectDbl1BasedExcludingZeros() {
     final int len = 64;
@@ -164,6 +203,39 @@ public void checkQuickSelectDbl1BasedIncludingZeros() {
   }
 
 
+  //select rearranges its input, so each call needs a fresh array
+  private static long[] ascending(final int len) {
+    final long[] a = new long[len];
+    for (int i = 0; i < len; i++ ) {
+      a[i] = i;
+    }
+    return a;
+  }
+
+  private static long[] descending(final int len) {
+    final long[] a = new long[len];
+    for (int i = 0; i < len; i++ ) {
+      a[i] = (len - 1) - i;
+    }
+    return a;
+  }
+
+  private static double[] ascendingDbl(final int len) {
+    final double[] a = new double[len];
+    for (int i = 0; i < len; i++ ) {
+      a[i] = i;
+    }
+    return a;
+  }
+
+  private static double[] descendingDbl(final int len) {
+    final double[] a = new double[len];
+    for (int i = 0; i < len; i++ ) {
+      a[i] = (len - 1) - i;
+    }
+    return a;
+  }
+
   /**
    * Rearrange the elements of an array in random order.
    * @param a long array