Quicksort avec tri par insertion en java

Bonjour, j'ai essayé d'implémenter mon algorithme quicksort avec un tri par insertion en fonction de la façon dont notre professeur nous a dit, mais je ne peux tout simplement pas savoir exactement quoi faire...Et le pseudo-code de mon professeur semble ne pas m'aider beaucoup... Quoi qu'il en soit, j'ai cherché en ligne mais je ne trouve rien. Voici le pseudo code qu'il nous gave

voidTQuickSort(int[]A, low,high)
while low < high do
p = DPartition(A,low,high)
TQuicksort(A,low,high)
low = p + 1
end while

Il a également dit "Dans quicksort, passez à insertionSort pour les appels récursifs sur les petites sous-rangées, après le partitionnement, récursez d'abord les petites sous-rangées et puis faites un appel de queue à un sous-réseau plus grand "

Tout d'abord, j'aimerais savoir, qu'est-ce qu'un appel de queue, et de quel tableau parle-t-il? Dans mon quicksort original, j'ai ceci

public void quicksort(int numbers[], int start, int end)   
    {   
        //Condition to continue recursion
        if(start < end)
        {
            //Set up my index as the start or end point for recursion
            int myIndex = partition(numbers, start, end);

            //Recursive algorithm for left and right side of the array
            quicksort(numbers, start, myIndex-1);
            quicksort(numbers, myIndex + 1, end);
        }
    }

Et dans ma tentative, j'obtiens un débordement de pile, cependant, si je replace ces deux sous-tableaux dans la boucle while, mon runtime passe de 1 ms sur quicksort, à 24 ms pour le quicksort soi-disant "amélioré"

Voici la tentative

public void quicksortImproved(int numbers[], int start, int end)   
    {   

        //Condition to continue recursion
        while(start < end)
        {
            //Set up my index as the start or end point for recursion
            int myIndex = partition(numbers, start, end);

            //Recursive algorithm
            quicksortImproved(numbers, start, end);
            start = myIndex + 1;
        }
        insertionSortTwo(numbers);


    }

Toute aide est appréciée! Merci

Fonction partition et insertionsortTwo

public int partition(int[] numbers, int start, int end)
    {
        //Declaring my pivot, start and end indexes
        int pivot = numbers[end];
        int small = start;
        int big = end - 1;

        //Begin loop while index of small is less than index of big
        while(small <= big)
        {
            //If the element @ numbers[small] is smaller than element at pivot
            //Then increment small index by 1
            while (small <= big && numbers[small] <= pivot)
            {
                small++;
            }
            //If the element @ numbers[big] is bigger than element at pivot
            //Then decrement index by 1
            while(big >= small && numbers[big] >= pivot)
            {
                big--;
            }
            //If small index is smaller than big index
            //Swap elements @ number[small] with element @ number[big]
            if(small < big)
            {
                numbers[small] = returnFirst(numbers[big], numbers[big] = numbers[small]);
            }
        }
        //Swap pivot with the presumed middle element and return small index
        numbers[end] = returnFirst(numbers[small], numbers[small] = numbers[end]);
        return small;
    }


    public void insertionSortTwo(int[] numbers)
    {
        //Loop from index 1 to end, element @ numbers[0] is in the sorted array
        for (int i = 1; i < numbers.length; i++)
        {
            //Setting up second array index variable
            //Loop to create new array in sorted order
            for(int j = i; j > 0 && numbers[j] < numbers[j - 1]; j--)
            {
                //If element @ number[j] is smaller than element @ number[j - 1]
                //swap element @ numbers[j] with element @ numbers[j - 1] and decrement j
                numbers[j] = returnFirst(numbers[j - 1], numbers[j - 1] = numbers[j]);
            }
        }
    }