Quick Sort - Vergleichsoperationen zählen

[Xyarvius]

Hallo,

ich möchte drei Funktion realisieren, die ein übergebenes Array mittels Insertion Sort, Quick Sort mit mittlerem Pivot und Quick Sort mit randomisiertem Pivot sortieren (die Elemente des übergebenen Arrays sollen comparable sein).
Der Clou dabei ist, dass die Funktionen die Anzahl der Vergleichsoperationen mitzählen und dann returnen sollen.
Für Insertion und Quick Sort mit mittlerem Pivot-Element habe ich bis jetzt folgenden Code:

public class Sorter {
    // nutzt Insertion Sort um ein übergebenes Array zu sortieren
    public static int insertionSort(Comparable[] toSort){
        // Anzahl der Vergleichsoperationen
        int counter= 0;
        // temporärer "Zwischenspeicher"
        Comparable tmp;
        //jedes Element (aßer dem ersten) mit allen Elementen link vergleichen und einordnen
        for (int i = 1; i < toSort.length; i++) {
            tmp = toSort[i];
            int j = i;
            //hier findet der Verhleichsprozess statt und wird counter erhöht 
            while (j > 0 && counter++>=0 && toSort[j - 1].compareTo(tmp) > 0) {
                toSort[j] = toSort[j - 1];
                j--;
            }
            toSort[j] = tmp;
        }
        return counter;
    }   
   
    // nutzt Quick Sort mit mittlerem Pivot um ein übergebenes Array zu sortieren
    public static int quickSortMid (Comparable[] toSort){
        // Anzahl der Vergleichsoperationen
        int counter= 0;
        return qSortMid(toSort, 0, toSort.length -1, counter);
    }
   
    // führt den eigentlichen Sortierprozess aus
    public static int qSortMid(Comparable[] toSort, int low, int high, int counter) {
        //bestimmt den mittleren Index des betrachteten Arrays/Arraybereiches
        int middle = low + (high - low) / 2;
        //bestimmt das mittlere Pivot
        Comparable pivot = toSort[middle];

        int i = low, j = high;
        //vergleicht die Elemente mit dem Pivotelement und sortiert die kleineren Elemente link, die größeren rechts 
        while (i <= j) {
            //in beiden Schleifen wird bei jeder Vergleichsoperation auch counter erhöht
            while (counter++ >= 0 && toSort[i].compareTo(pivot) < 0) {
                i++;
            }
            while (counter++ >= 0 && toSort[j].compareTo(pivot) > 0) {
                j--;
            }
            if (i <= j) {
                Comparable tmp = toSort[i];
                toSort[i] = toSort[j];
                toSort[j] = tmp;
                i++;
                j--;
            }
        }
        //sortiert die entstandenen kleineren Abschnitte rekursiv
        if (low < j)
            qSortMid(toSort, low, j, counter);

        if (high > i)
            qSortMid(toSort, i, high, counter);
       
        return counter;
    }
    //Testfunktion um Funktionalität zu prüfen
    public static void main(String[] args) {
        String [] x = {"C", "A", "B", "E", "Z", "J", "O"};
        Comparable [] y = {6,2,7,0,1,4,3,9,5,8};
        System.out.println(insertionSort(x));
        for (int i=0; i<x.length;i++){
            System.out.print(x[i]);
        }
        System.out.println("\n-------------");
        System.out.println(quickSortMid(y));
        for (int i=0; i<y.length;i++){
            System.out.print(y[i]);
        }
    }
}

Die Funktion die mit Insertion Sort arbeitet funktioniert schon mal (d.h. sie sortiert korrekt und zählt auch die Vergleichsoperationen korrekt).
Jetzt habe ich aber ein Problem damit, bei der (bzw. den beiden) Funktionen die mit Quick Sort arbeiten (ob mittleres oder randomisiertes Pivot dürfte an dem Problem nichts ändern).

Die Funktion qSort, die den eigentlichen Sortierprozess macht, arbeitet ja rekursiv. Dadurch habe ich am Ende das Problem, dass die Variable counter, die die Vergleichsoperationen mitzählt, nicht richtig ausgegeben wird.

Für das in der Testfunktion definierte Array {6,2,7,0,1,4,3,9,5,8} bekomme ich z.B. nur 12 Vergleichsoperationen. Das ist eindeutig zu wenig.

Als Java Laie weiß ich jetzt nicht, wie ich das Problem lösen kann. Das hat sicher was mit dem Wesen von Rekursion zu tun.