Modyfikacja quicksort

Witam chciał bym się dowiedzieć w jaki sposób można uzyskać pesymistyczną złożoność pamięciową algorytmu quicksort rzędu O(1) ?
Proszę o jakieś wskazówki oto mój kod :

import java.util.Scanner;

public class Source {
	private static long tab[];
	private static int ilosc_liczb;
	public static void main(String[] args) {
		Scanner inScan = new Scanner(System.in);
		ilosc_liczb = inScan.nextInt();
		tab = new long[ilosc_liczb];

		for (int i = 0; i < ilosc_liczb; i++) { // wprowadzanie liczb do tablicy
			tab[i] = inScan.nextLong();
		}
		quicksort(0, ilosc_liczb - 1);

		for (int i = 0; i < ilosc_liczb; i++) { // po sortowaniu
			System.out.print(tab[i] + " ");
		}
	}
	static public void swap(int i, int j) { //zamiana 
        long temp = tab[i];
        tab[i] = tab[j];
        tab[j] = temp;
    }
	static long mediana(int L, int P) { //mediana
        int C = (L + P) / 2;
 
        if (tab[L] > tab[C]) {
            swap(L, C);
        }
 
        if (tab[L] > tab[P]) {
            swap(L, P);
        }
 
        if (tab[C] > tab[P]) {
            swap(C, P);
        }
 
        return tab[P];
 
    }

	private static void quicksort( int L, int P) {

		int pomL, pomP, temp;
		long dzielnik_przedzialu;

		pomL = L;
		pomP = P;
		dzielnik_przedzialu = mediana(L,P);
		do {
			while (tab[pomL] <dzielnik_przedzialu )
				pomL++;
				
			while (dzielnik_przedzialu < tab[pomP])
				pomP--;
				
			if (pomL <= pomP) {
				temp = (int) tab[pomL];
				tab[pomL] = tab[pomP];
				tab[pomP] = temp;
				pomL++;
				pomP--;
			}
		} while (pomL <= pomP);
		
		if (L < pomP)
			quicksort(L, pomP);
		if (pomL < P)
			quicksort(pomL, P);
	}
	
	
	
}
	
	

Nie da się. Quicksort potrzebuje przynajmniej stosu o głębokości O(lg n) indeksów tablicy.