Ciao a tutti, sono nuovo del forum, mi sono inscritto dopo aver provato e riprovato a risolvere un problema di segmentation fault di un piccolo programma in C.
Premetto che non è molto tempo che inserisco i puntatori nei codici C e l'approccio iniziale chiaramente non è dei migliori!!!
Comunque il programma riceve un array di dimensioni "dim" (dim viene inserita da tastiera).
La procedura "leggi" asseggna ai valori dell'array un numero randomico tra 1000 e -1000.
Successivamente la procedura distribuzione provvede a separare i numeri pari da quelli dispari, in pratica dopo la procedura nell'array saranno verranno prima tutti i numeri pari e successivamente tutti quelli dispari.
Infine tratto l'array come se fosse composto da due segmenti, il primo che comprende tutti i numeri pari e il secondo tutti quelli dispari, ordino entrambi i segmenti con una procedura di "QuickSort" anch'essa definita dentro il codice, senza utilizzare la "qsort" della libreria standard.

Compilo sotto linux con:

# gcc -o QSortPD.exe QSortPD.c

Quando vado ad eseguire il codice compilato con:

# ./QSortPD.exe

Mi chiede la dimensione dell'array, mi genera i valori randomici stampandomeli a video e successivamente viene il simpatico

segmentation fault

LISTATO
  • #include<stdio.h>
    #include<stdlib.h>

    #define RANGE 1000

    void scambia(int *a, int *b)
    {
    int tmp= *a;
    *a = *b;
    *b = tmp;
    }

    int distribuzione(int A[], int sx, int px, int dx)
    {
    int i, j;
    if(px != sx)
    scambia(&A[sx], &A[px]);

    px=sx;

    for(i=sx, j=sx+1; j<dx; j++)
    if(A[j]<A[px])
    scambia(&A[++i],&A[j]);

    if(px != i)
    scambia(&A[px], &A[i]);

    return i;
    }

    void QuickSort (int A[], int sx, int dx)
    {
    int perno, pivot;
    if(sx<dx)
    {
    pivot = random()%(dx-sx+1);
    perno = distribuzione(A, sx, pivot, dx);

    QuickSort (A,sx,perno-1);
    QuickSort (A,sx,perno+1);
    }
    }

    void disposizione(int A[], int dim)
    {
    int i=0, j=dim;
    while(i != j)
    {
    if(A[i] % 2 != 0)
    {
    scambia(&A[i], &A[j]);
    j--;
    }
    else i++;
    }
    }

    int leggi(int **A, int *dim)
    {
    int i;

    printf("Quanti lementi deve contenere l'array?\n");
    scanf("%d", dim);
    if(*dim<=0) return 1;

    *A = (int*)malloc(sizeof(int)*(*dim));
    if(*A==NULL) return 1;

    for(i=0; i<*dim; i++)
    {
    *((*A)+i)= (random()%((RANGE*2)+1)-RANGE);
    printf("%d - %d\n", i, ((**A)+i));
    }
    return 0;
    }

    int main()
    {
    int i, cx=0, *A, dim;

    srand(time (NULL));

    leggi(&A, &dim);
    disposizione(A, dim);

    while((A[cx]%2)==0)
    cx++;

    QuickSort(A, 0, cx);
    QuickSort(A, cx+1, dim);

    return 0;
    }