QSorting 2D Pointer Arrays

Question

Sto cercando di ordinare una serie 2D di puntatori usando QSORT.L'unico problema che ho adesso è originariamente che stavo usando gli array dichiarati staticamente ora passati ai puntatori.Sono quasi tentato di passare a strisce ma essere testardi che non riesco a far funzionare questo.

Finora I Malloc La matrice 2D dei puntatori [Array2D [M] [3] è stata la dimensione prevista]:

     int **array2d;

     array2d = (int**)malloc((m)*sizeof(int*));

     for(i=0; i<=m; i++)
       array2d = [i]=(int*)malloc(3*sizeof(int));
     qsort(array2d, m, 3*sizeof(int**),comp);

.

Il mio confronto è:

int comp(const void* left, const void*right)                                                                                  
{

  const int *a = *(const int**)left;
  const int *b = *(const int**)right;

  return a-b;
}

.

Anche se non sono sicuro di come strutturare il confronto con il lavoro con i punti 2D.

Answer 1

Dal snippet di codice che hai fornito, suppongo che tu stia cercando di ordinare ogni riga della matrice separatamente. La prima cosa che ho notato è che c'è un errore di battitura nell'assegnazione della memoria delle colonne (2nd index) della matrice.

Assegnazione della memoria corretta di un NumRow X Numcolumns Matrix sarebbe il seguente:

/* loop counter */
int i;

/* dynamic array sizes */
const int numRow = 5;
const int numColumns = 25;

/* allocate the row pointers */
int **dynamic2d = (int **)malloc(numRow * sizeof(int *));

/* for each row pointer */
for(i = 0; i < numRow; i++)
{
    /* allocate columns */
    dynamic2d[i] = (int *)malloc(numColumns * sizeof(int));
}

.

Avanti Non sarai in grado di chiamare semplicemente il metodo QSort (..) solo una volta. Quel metodo si aspetta un'array "piatta" o unidimensionale. Avrai bisogno di chiamare il metodo QSort (...) separatamente per ogni riga della matrice. Questo è dimostrato di seguito:

/* sort array */
for(i = 0; i < numRow; i++)
    qsort(dynamic2d[i], numElements, sizeof(int *), comp);

.

Infine, hai commesso un errore con il tuo metodo del comparatore. Questo metodo ha regole rigorose che devono essere seguite per funzionare correttamente. Attuale Specifiche dicono, " La domanda deve assicurarsi che la funzione restituisce un numero intero inferiore a, uguale a, o superiore a 0, se il primo argomento è considerato rispettivamente inferiore a, uguale o superiore al secondo. Se due membri confrontano come uguali, il loro ordine nell'array ordinato non è specificato. < / Strong> "

Questa è una semplice correzione. Basta scrivere la logica per produrre quei risultati come visto di seguito:

int comp(const void* firstArg, const void* secondArg)
{
   /* get the values of the arguments */
   int first = *(int *)firstArg;
   int second = *(int *)secondArg;

   /* return the value as expected by the qsort() method */
   if(first < second)
   {
      return 1;
   }
   else if(second < first)
   { 
     return -1;
   }

   return 0;
}

.

L'ultima cosa da notare, questo genererà più grande almeno. Non cambiare la logica nel confronto se vuoi che meno grande. Il tipo non restituirà risultati accurati. Il modo corretto di farlo è leggendo l'array da tornare alla parte anteriore come visto di seguito: è possibile scambiare gli argomenti nel comparatore per modificare l'ordine di ordinamento o leggere i risultati da Torna alla parte anteriore.

int comp(const void* firstArg, const void* secondArg)
{
    /* get the values of the arguments */
    int first = *(int *)secondArg;
    int second = *(int *)firstArg;
    ...
}

.

o

/* print greatest to smallest */
for(i = 0; i < numRow; i++)
{
    /* start at front and work to back */
    for(j = 0; j < numColumns; j++)
        printf("%d ", dynamic2d[i][j]);
    printf("\n");
}

/* print smallest to greatest */
for(i = 0; i < numRow; i++)
{
    /* start at back and work to front */
    for(j = numColumns- 1; j >= 0; j--)
        printf("%d ", dynamic2d[i][j]);
    printf("\n");
}

.

Speriamo che questo aiuti! Se hai bisogno di ordinare l'intera matrice nel suo insieme ... questa è una bestia diversa insieme.