Redigerer Kvikksortering (avsnitt)

===Jaroslavskijs metode===
Jaroslavskijs metode benytter to «dreietapper».<ref name="Jaroslavskij2009"/> Den partisjonerer den usorterte tabellen {{mono|'''T [] a'''}}, hvor {{mono|'''T'''}} er en primitiv type ([[heltall]], [[flyttall]], [[byte]], [[tegn]], [[dobbelpresisjons flyttallsformat|dobbel]], langt heltall og kort heltall) som defineres av to «dreietapper» {{mono|'''P1'''}} og {{mono|'''P2'''}}. Det er derfor tre pekere, {{mono|'''L'''}}, {{mono|'''K'''}}, {{mono|'''G'''}}, og to indekser, {{mono|'''left'''}} and {{mono|'''right'''}}, som peker på henholdsvis det første og det siste elementet.<ref name="Jaroslavskij2009"/> Algoritmen består av følgende trinn:<ref name="Jaroslavskij2009"/>

# For mindre tabeller (lengde < 27) bruk innstikksortering
# Velg to «dreietapper» {{mono|'''P1'''}} og {{mono|'''P2'''}}. Vi kan for eksempel, velge det første elementet {{mono|'''a[left]'''}} som {{mono|'''P1'''}} og det siste elementet {{mono|'''a[right]'''}} som {{mono|'''P2'''}}
# {{mono|'''P1'''}} må være mindre enn {{mono|'''P2'''}}. I motsatt fall må de byttes om. Det er derfor fire deler:
##del 1 som indekserer fra {{mono|'''left+1'''}} til {{mono|'''L-1'''}}, med elementer som er mindre enn {{mono|'''P1'''}}
##del 2 som indekserer fra {{mono|'''L'''}} til {{mono|'''L-1'''}}, med elementer som er større enn eller lik {{mono|'''P1'''}} og mindre enn eller lik {{mono|'''P2'''}}
##del 3 som indekserer fra {{mono|'''G+1'''}} til {{mono|'''right–1'''}} med elementer som er større enn {{mono|'''P2'''}}
##del 4 inneholder resten av indeksene fra {{mono|'''K'''}} til {{mono|'''G'''}}
#Det neste elementet ved {{mono|'''a[left]'''}} i del 4 blir sammenlignet med de to «dreiebenkene» {{mono|'''P1'''}} og {{mono|'''P2'''}}, og plasseres i den korresponderende del 1, del 2, eller del 3
#Pekerne {{mono|'''L'''}}, {{mono|'''K'''}} og {{mono|'''G'''}} forandres i de korresponderende retninger
#Trinnene 4 og 5 blir repetert så lenge {{mono|'''K ≤ G'''}}
#«Dreietappen» {{mono|'''P1'''}} blir byttet med det siste elementet fra del 1, og «dreietappen» {{mono|'''P2'''}} blir byttet med det siste elementet fra del 3
# Trinn 1-7 blir gjentatt rekursivt for hver enkelt del, del 1, del 2 og del 3

Her er koden for Jaroslavskijs metode, skrevet i programmeringsspråket Java:<ref name="Jaroslavskij2009"/>

<syntaxhighlight lang="C">
  public static void sort(int[] a) {
     sort(a, 0, a.length);
  }

  public static void sort(int[] a, int fromIndex, int toIndex) {
     rangeCheck(a.length, fromIndex, toIndex);
     dualPivotQuicksort(a, fromIndex, toIndex - 1, 3);
  }

  private static void rangeCheck(int length, int fromIndex, int toIndex) {
    if (fromIndex > toIndex) {
       throw new IllegalArgumentException("fromIndex > toIndex");
    }
    if (fromIndex < 0) {
       throw new ArrayIndexOutOfBoundsException(fromIndex);
    }
    if (toIndex > length) {
       throw new ArrayIndexOutOfBoundsException(toIndex);
    }
  }

  private static void swap(int[] a, int i, int j) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
  }

  private static void dualPivotQuicksort(int[] a, int left,int right, int div) {
    int len = right - left; 
    if (len < 27) { // insertion sort for tiny array
      for (int i = left + 1; i <= right; i++) {
        for (int j = i; j > left && a[j] < a[j - 1]; j--) {
          swap(a, j, j - 1);
        }
      }
    return;
    }
    int third = len / div;
    // «medianer»
    int m1 = left + third;
    int m2 = right - third;

    if (m1 <= left) {
       m1 = left + 1;
    }
    if (m2 >= right) {
       m2 = right - 1;
    }
    if (a[m1] < a[m2]) {
      swap(a, m1, left);
      swap(a, m2, right);
    } else {
     swap(a, m1, right);
     swap(a, m2, left);
    }

    // dreietapper
    int pivot1 = a[left];
    int pivot2 = a[right];

    // pekere
    int less = left + 1;
    int great = right - 1;

  // sortering
    for (int k = less; k <= great; k++) {
       if (a[k] < pivot1) {
       swap(a, k, less++);
    }
    else if (a[k] > pivot2) {
       while (k < great && a[great] > pivot2) {
       great--;
       }
       swap(a, k, great--);
       if (a[k] < pivot1) {
          swap(a, k, less++);
       }
    }
  }
  // ombyttinger
  int dist = great - less;

  if (dist < 13) {
     div++;
  }
  swap(a, less - 1, left);
  swap(a, great + 1, right);
  // undertabeller
  dualPivotQuicksort(a, left, less - 2, div);
  dualPivotQuicksort(a, great + 2, right, div);
  // like elementer
     if (dist > len - 13 && pivot1 != pivot2) {
        for (int k = less; k <= great; k++) {
        if (a[k] == pivot1) {
          swap(a, k, less++);
        } else if (a[k] == pivot2) {
            swap(a, k, great--);
        if (a[k] == pivot1) {
           swap(a, k, less++);
        }
      }
    }
  }
  // undertabeller
  if (pivot1 < pivot2) {
    dualPivotQuicksort(a, less, great, div);
  }
  }
</syntaxhighlight>