Festgefahren in einer einfachen Schnellsortierimplementierung mit zufälligem Pivot

Question

Ich überprüfe gerade Algorithmen und stecke in einer einfachen Implementierung eines schnellen Sortieralgorithmus in Java fest

import java.util.Arrays;
import java.util.Random;

public class QuickSort {
    int arr[];
    boolean randomPick;
    Random rand = null;

    public QuickSort(int[] inputArray) {
        arr = inputArray;
        randomPick = false;
    }

    public QuickSort(int[] inputArray, boolean random) {
        arr = inputArray;
        if (random) {
            randomPick = true;
            rand = new Random(System.currentTimeMillis());
        }
        else {
            randomPick = false;
        }
    }

    public int[] sort() {
        int start = 0;
        int end = arr.length - 1;
        try {
            _sort(start, end);
        }
        catch (StackOverflowError e) {
            System.out.println("StackOverflow: " + Arrays.toString(arr));
        }
        return arr;
    }

    private void _sort(int start, int end) {
        int i = start;
        int j = end;
        int pivotLoc;
        if (!randomPick) {
            pivotLoc = (j + i) / 2;
        }
        else {
            pivotLoc = rand.nextInt(j - i) + i;
        }
        int pivot = arr[pivotLoc];
        while (i < j) {   // swapping numbers around the pivot
            while (arr[i] < pivot) {
                i++;
            }
            while (arr[j] > pivot) {
                j--;
            }
            if (i < j) {
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
                i++;
                j--;
            }
        }
        if (i - start > 1) {
            _sort(start, i);
        }
        if (end - i > 1) {
            _sort(i, end);
        }
    }
}

Der Code kann entweder die mittlere Zahl als Drehpunkt wählen oder eine zufällige Zahl als Drehpunkt wählen und das Array durch den Aufruf von _sort wiederkehrend. Im ersten Fall funktioniert es, im zweiten Fall nicht.

Die Situation ist folgende: Wenn ein Unterarray wie dieses {3,5,5} erreicht wird, ist i==start==0 und j==end==2. Schließlich werden 5 und 5 vertauscht, i wird 2 und j wird 1 (i++ und j--). Da dann i - start>1 ruft es _sort immer und immer wieder und rufen schließlich den Stackoverflow-Fehler hervor. Der Fehler soll jedoch im ersten Fall (fester Drehpunkt) auftreten, was bisher nicht geschehen ist...

Ich weiß nicht, was an meinem Code falsch ist. Ich weiß, es ist kein Vergnügen, von anderen geschriebenen Code zu lesen, aber jede Hilfe?