Funktionsaufruf

blurry333

Hier eine Version des Quicksort wobei ein Teil als partition ausgelagert wurde.

int partition(int* input, int p, int r)
{
    int pivot = input[r];

    while ( p < r )
    {
        while ( input[p] < pivot )
            p++;

        while ( input[r] > pivot )
            r--;

        if ( input[p] == input[r] )
            p++;
        else if ( p < r )
        {
            int tmp = input[p];
            input[p] = input[r];
            input[r] = tmp;
        }
    }

    return r;
}

void quicksort(int* input, int p, int r)
{
    if ( p < r )
    { 
        int j = partition(input, p, r);        
        quicksort(input, p, j-1);
        quicksort(input, j+1, r);
    }
}

blurry333

Wenn ich partition jetzt nicht mehr auslagere funktioniert es auf einmal nicht mehr. Statt dem Funktionsaufruf kopiere ich das was in der Funktion steht alles in quicksort rein.

void quicksort(int* input, int p, int r)
{
    if ( p < r )
    {
		 int pivot = input[r];   // hier gehts los mit partition

    while ( p < r )
    {
        while ( input[p] < pivot )
            p++;

        while ( input[r] > pivot )
            r--;

        if ( input[p] == input[r] )
            p++;
        else if ( p < r )
        {
            int tmp = input[p];
            input[p] = input[r];
            input[r] = tmp;
        }
    }
        int j = r;       // hier der return wert von partition 
        quicksort(input, p, j-1);
        quicksort(input, j+1, r);
    }
}

Benenne die Variablen p und r in partition mal in pp und rr um und füge das dann nochmal ein.

Die Veränderungen in partition bei p und r haben keinen Einfluss auf das p und r von quicksort.
Innerhalb von quicksort dagegen schon.

daddy_felix

"p" und "r" werden per value an "partition" übergeben.

Wenn du den Code in die "Hauptfunktion" reinkopierst, musst du darauf achten, "p" und "r" am Anfang zu sichern, damit der rekursive Aufruf von "quicksort" nicht mit veränderten Werten vorgenommen wird.

blurry333

jetzt gehts . Danke

void quicksort(int* input, int p, int r)
{
    if ( p < r )
    {
		int rr = r;
		int pp = p; 
		int pivot = input[rr];

    while ( pp < rr )
    {
        while ( input[pp] < pivot )
            pp++;

        while ( input[rr] > pivot )
            rr--;

        if ( input[pp] == input[rr] )
            pp++;
        else if ( pp < rr )
        {
            int tmp = input[pp];
            input[pp] = input[rr];
            input[rr] = tmp;
        }
    }
        int j = rr;      
        quicksort(input, p, j-1);
        quicksort(input, j+1, r);
    }
}