AK: Guarantee a maximum stack depth for dual_pivot_quick_sort

When the two chosen pivots happen to be the smallest and largest
elements of the array, three partitions will be created, two of
size 0 and one of size n-2. If this happens on each recursive call
to dual_pivot_quick_sort, the stack depth will reach approximately n/2.

To avoid the stack from deepening, iteration can be used for the
largest of the three partitions. This ensures the stack depth
will only increase for partitions of size n/2 or smaller, which
results in a maximum stack depth of log(n).

AK/QuickSort.h

@@ -18,62 +18,75 @@ namespace AK {
 template<typename Collection, typename LessThan>
 void dual_pivot_quick_sort(Collection& col, int start, int end, LessThan less_than)
 {
- int size = end - start + 1;
- if (size <= 1) {
- return;
- }
-
- if (size > 3) {
- int third = size / 3;
- if (less_than(col[start + third], col[end - third])) {
- swap(col[start + third], col[start]);
- swap(col[end - third], col[end]);
+ while (start < end) {
+ int size = end - start + 1;
+ if (size > 3) {
+ int third = size / 3;
+ if (less_than(col[start + third], col[end - third])) {
+ swap(col[start + third], col[start]);
+ swap(col[end - third], col[end]);
+ } else {
+ swap(col[start + third], col[end]);
+ swap(col[end - third], col[start]);
+ }
  } else {
- swap(col[start + third], col[end]);
- swap(col[end - third], col[start]);
- }
- } else {
- if (!less_than(col[start], col[end])) {
- swap(col[start], col[end]);
+ if (!less_than(col[start], col[end])) {
+ swap(col[start], col[end]);
+ }
  }
- }
 
- int j = start + 1;
- int k = start + 1;
- int g = end - 1;
+  int j = start + 1;
+  int k = start + 1;
+  int g = end - 1;
 
- auto&& left_pivot = col[start];
- auto&& right_pivot = col[end];
+  auto&& left_pivot = col[start];
+  auto&& right_pivot = col[end];
 
- while (k <= g) {
- if (less_than(col[k], left_pivot)) {
- swap(col[k], col[j]);
- j++;
- } else if (!less_than(col[k], right_pivot)) {
- while (!less_than(col[g], right_pivot) && k < g) {
- g--;
- }
- swap(col[k], col[g]);
- g--;
+ while (k <= g) {
  if (less_than(col[k], left_pivot)) {
  swap(col[k], col[j]);
  j++;
+ } else if (!less_than(col[k], right_pivot)) {
+ while (!less_than(col[g], right_pivot) && k < g) {
+ g--;
+ }
+ swap(col[k], col[g]);
+ g--;
+ if (less_than(col[k], left_pivot)) {
+ swap(col[k], col[j]);
+ j++;
+ }
  }
+ k++;
+ }
+ j--;
+ g++;
+
+ swap(col[start], col[j]);
+ swap(col[end], col[g]);
+
+ int left_pointer = j;
+ int right_pointer = g;
+
+ int left_size = left_pointer - start;
+ int middle_size = right_pointer - (left_pointer + 1);
+ int right_size = (end + 1) - (right_pointer + 1);
+
+ if (left_size >= middle_size && left_size >= right_size) {
+ dual_pivot_quick_sort(col, left_pointer + 1, right_pointer - 1, less_than);
+ dual_pivot_quick_sort(col, right_pointer + 1, end, less_than);
+ end = left_pointer - 1;
+ } else if (middle_size >= right_size) {
+ dual_pivot_quick_sort(col, start, left_pointer - 1, less_than);
+ dual_pivot_quick_sort(col, right_pointer + 1, end, less_than);
+ start = left_pointer + 1;
+ end = right_pointer - 1;
+ } else {
+ dual_pivot_quick_sort(col, start, left_pointer - 1, less_than);
+ dual_pivot_quick_sort(col, left_pointer + 1, right_pointer - 1, less_than);
+ start = right_pointer + 1;
  }
- k++;
  }
- j--;
- g++;
-
- swap(col[start], col[j]);
- swap(col[end], col[g]);
-
- int left_pointer = j;
- int right_pointer = g;
-
- dual_pivot_quick_sort(col, start, left_pointer - 1, less_than);
- dual_pivot_quick_sort(col, left_pointer + 1, right_pointer - 1, less_than);
- dual_pivot_quick_sort(col, right_pointer + 1, end, less_than);
 }
 
 template<typename Iterator, typename LessThan>