Vecchio problema con QuickSort

[Darèios89]

Non capisco perchè questi algoritmi che ho scritto in passato non funzionino, praticamente ho un ArrayIndexOutOfBoundsException, ma non sono riuscito a capire perchè nel Quicksort non funzioni la procedura partition:

public class QuickSort
{
	public static void main(String [] args)
	{
		int [] a={5,4,6,7,8,0};
		QSort(a,0,a.length-1);
	}
	
	
	public static void QSort(int [] A, int i, int r)
	{
		if(i>=r) return;
		else{
			int n=partition(A,i,r);
			QSort(A,i,n);
			QSort(A,n+1,r);
			}
	}

	public static int partition(int [] A, int i, int r)
	{
		int a=i-1;
		int b=r+1;
		int p=A[r];
		
		while(true)
		{
			b--;
			
			while(A[b]>p)
				b--;
			
		     a=a+1;
			
			while(A[a]<p)
				a=a+1;
			if(a<b)
				swap(A, a, b);
			
		else return p;
		}
	}
	
	public static void swap(int [] A,int a, int b)
	{
		int tmp=A[a];
		A[a]=A[b];
		A[b]=tmp;
	}
	
	
}

[valia]

sarebbe bello sapere anche dove hai l'eccezione (la riga è in genere indicata), quanto valgono gli indici i e r (nomi più significativi sono anche graditi) quando si verifica l'eccezione

[Darèios89]

Hai ragione, la fretta a volte...non fa ragionare la mente...

Allora ecco il codice con le righe dove si verifica l' eccezione:

public class QuickSort
{
	public static void main(String [] args)
	{
		int [] a={5,4,6,7,8,0};
		QSort(a,0,a.length-1); //lancio eccezione
	}
	
	
	public static void QSort(int [] A, int i, int r)
	{
		if(i>=r) return;
		else{
			int n=partition(A,i,r);        //eccezione
			QSort(A,i,n);                     //eccezione
			QSort(A,n+1,r);                 //eccezione
			}
	}

	public static int partition(int [] A, int i, int r)
	{
		int a=i-1;
		int b=r+1;
		int p=A[r];           //eccezione
		
		while(true)
		{
			b--;
			
			while(A[b]>p)
				b--;
			
		     a=a+1;
			
			while(A[a]<p)
				a=a+1;
			if(a<b)
				swap(A, a, b);
			
		else return p;
		}
	}
	
	public static void swap(int [] A,int a, int b)
	{
		int tmp=A[a];
		A[a]=A[b];
		A[b]=tmp;
	}
	
	
}

Il compilatore riporta questo:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
	at QuickSort.partition(QuickSort.java:24)
	at QuickSort.QSort(QuickSort.java:14)
	at QuickSort.QSort(QuickSort.java:15)
	at QuickSort.QSort(QuickSort.java:15)
	at QuickSort.QSort(QuickSort.java:16)
	at QuickSort.main(QuickSort.java:6)
>Exit code: 1

Per quanto riguarda gli indici il metodo è:

public static void QSort(int [] A, int i, int r)

La chiamata è:

QSort(a,0,a.length-1);

Quindi ad i assegno 0 mentre ad r length-1

[valia]

ok hai implementato male l'algoritmo

 public QuickSort() {
        ;
    }

    public static void main(String[] args) {
        int[] vector = {5, 4, 6, 7, 8, 0};
        QuickSort quick = new QuickSort();
        quick.QSort(vector, 0, (vector.length - 1));
        for (int index = 0; index < vector.length; index++) System.out.println(vector[index]);
    }

    public void QSort(int[] vector, int first, int second) {
        int index = partition(vector, first, second);
        if (first < index - 1) {
            QSort(vector, first, index - 1);
        }
        if (index < second) {
            QSort(vector, index, second);
        }
    }

    /*come elemento pivot prendo quello centrale */
    public int partition(int[] vector, int start, int end) {

        int i = start, j = end;
        int pivot = vector[(start + end) / 2];

        while (i <= j) {
            while (vector[i] < pivot) {
                i++;
            }
            while (vector[j] > pivot) {
                j--;
            }
            if (i <= j) {
                swap(vector, i, j);
                i++;
                j--;
            }
        }
        return i;
    }

swap va bene, quindi non l'ho riportato.
L'errore sta nell'elemento pivot che consideri. Io non guardo al contenuto di pivot, prendo solo l'elemento che sta al centro dell'array e su quello lavoro. Credo che il tuo errore venga dal punto di partenza, partendo dalla fine ogni volta che aumenti/diminuisci vai in eccezione.
Come vedi non uso nemmeno cicli infiniti (a differenza tua).
Infine cambia anche il qSort, come puoi notare.
Dubito che così come lo hai scritto in passato abbia funzionato (non ne capisco nemmeno la logica)