C- Sortieren eines Arrays von Zeigern auf ganze Zahlen, die positiv oder negativ sein können

Question

Für Klasse muss ich ein Array von 100 ganzen Zahlen zwischen einem Minimum und einem Maximum (das funktioniert jetzt gut), und dann in einer separaten Funktion, Erstelle ein Array von Zeigern und sortiere es in aufsteigender Reihenfolge.

int *ptr ist ein Zeiger auf die ursprüngliche Anordnung und Größe ist als 100 in dem Kopf

void sort(int *ptr){ 
    int *sortAr[SIZE] = { NULL }; 
    int i = 0, j, swap; 
    for (i = 0; i < SIZE; i++) 
     sortAr[i] = ptr[i]; 
    for (i = 0; i < (SIZE - 1); i++) 
    { 
     for (j = 0; j < SIZE - i - 1; j++) 
     { 
      if (sortAr[j] > sortAr[j + 1]) 
      { 
       swap = sortAr[j]; 
       sortAr[j] = sortAr[j + 1]; 
       sortAr[j + 1] = swap; 
      } 
     } 
    } 
    int z = 0; 
    for (z = 0; z < SIZE; z++) 
     printf("%d\t", sortAr[z]); 
} 

Der Code definiert Ich verwende funktioniert gut, wenn alle Zahlen in der ursprünglichen Anordnung positiv oder negativ sind, aber Wenn es eine Mischung gibt, wird das Array so sortiert, dass es die positiven Zahlen in Asc-Reihenfolge enthält, und dann alle Assets in Asc-Reihenfolge. Zum Beispiel:

4  10  12  14  14  16  17  19  20  21 
28  33  35  35  36  38  39  41  41  41 
45  45  45  47  48  49  50  54  64  66 
67  68  70  72  73  73  74  75  75  76 
76  77  78  78  79  86  86  87  87  91 
92  95  95  98  -100 -99  -92  -86  -86  -84 
-82  -80  -78  -78  -76  -73  -73  -71  -70  -70 
-69  -64  -63  -63  -58  -56  -53  -50  -49  -48 
-44  -42  -36  -32  -30  -25  -24  -24  -21  -20 
-20  -19  -17  -17  -10  -6  -5  -4  -3  -3 

Irgendwelche Ideen, was geht?

Answer 1

Sie haben ein Original-Array von int übergeben, aber Sie haben es in ein Array von int* kopiert. Wenn Sie diese später vergleichen, haben Sie undefined Verhalten, weil Sie Zeiger nicht vergleichen dürfen, es sei denn, sie gehören zu demselben Speicherblock aus einer einzelnen Zuordnung.

Was tatsächlich passiert, ist, dass der Zeiger intern unsigned ist, so dass Ihre negativen Werte große positive Werte werden. Wie es der Zufall wollte, wird der Wert für den Aufruf printf korrekt an zurückgesendet, so dass es schwieriger ist zu erkennen, dass Sie etwas Schlechtes getan haben (es sei denn, Sie haben die Warnungen Ihres Compilers gelesen).

Erklären Sie Ihre Array wie folgt statt:

int sortAr[SIZE]; 

Answer 2

Sortieren Sie ein Array auf der Grundlage der Werte im Array gespeichert. Sie können sicherlich ein Array von Zeigern auf Referenz alle Werte im Array verwenden, aber mit dem Zeigerarray zu sortieren, müssen Sie die Zeiger dereferenzieren, so dass Sie tatsächlich basierend auf den Werten sortieren.

Zum Beispiel erstellt die folgenden ein zufälliges Array von 100 Werten zwischen -100 und 100, ein Array von Zeigern ordnet die Werte zu verweisen, und sortiert dann die Werte der Zeiger-Array unter Verwendung von:

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 

#define MAXI 100 

int main (void) { 

    int arr[MAXI] = {0}; 
    int *arrp[MAXI] = {NULL}; 
    int i, j, swap; 

    srand (time (NULL)); 

    for (i = 0; i < MAXI; i++) {   /* generate random values */ 
     arr[i] = rand() % (MAXI * 2 + 1) - MAXI; /* -100 < rand < 100 */ 
     arrp[i] = &arr[i];     /* assign pointer value */ 
    } 

    printf ("\noriginal array - by pointers\n\n"); 
    for (i = 0; i < MAXI; i++) { 
     if (i && !(i % 10)) putchar ('\n'); 
     printf (" %4d", *(arrp[i])); 
    } 
    putchar ('\n'); 

    for (i = 0; i < MAXI - 1; i++) {  /* sort pointer array */ 
     for (j = 0; j < MAXI - i - 1; j++) { 
      /* For decreasing order use < */ 
      if (*(arrp[j]) > *(arrp[j + 1])) { 
       swap = *(arrp[j]); 
       *(arrp[j]) = *(arrp[j + 1]); 
       *(arrp[j + 1]) = swap; 
      } 
     } 
    } 

    printf ("\nsorted array - by pointers\n\n"); 
    for (i = 0; i < MAXI; i++) { 
     if (i && !(i % 10)) putchar ('\n'); 
     printf (" %4d", *(arrp[i])); 
    } 
    putchar ('\n'); 

    return 0; 
} 

Beispiel Verwendung/Output

$ ./bin/bubblesort 

original array - by pointers 

    55 88 94 -50 64 -64 -23 39 43 -67 
    -75 44 -23 64 47 -18 -11 -50 76 -10 
    32 -35 -53 9 95 8 -28 53 -39 32 
    -88 67 -31 -94 -84 -68 93 -57 21 35 
    -74 46 -22 -46 9 76 36 99 -75 -39 
    -62 8 26 -65 67 -30 -6 -62 -77 5 
    21 86 -29 90 92 -63 73 85 -19 -7 
    19 -43 -61 48 11 48 23 97 -4 -2 
    -43 -16 -95 33 -30 72 -97 64 61 77 
    -32 -69 62 -10 -80 4 27 93 -12 58 

sorted array - by pointers 

    -97 -95 -94 -88 -84 -80 -77 -75 -75 -74 
    -69 -68 -67 -65 -64 -63 -62 -62 -61 -57 
    -53 -50 -50 -46 -43 -43 -39 -39 -35 -32 
    -31 -30 -30 -29 -28 -23 -23 -22 -19 -18 
    -16 -12 -11 -10 -10 -7 -6 -4 -2 4 
    5 8 8 9 9 11 19 21 21 23 
    26 27 32 32 33 35 36 39 43 44 
    46 47 48 48 53 55 58 61 62 64 
    64 64 67 67 72 73 76 76 77 85 
    86 88 90 92 93 93 94 95 97 99 

Sortierung Nur die Pointers

Wenn Sie nur das Array von Zeigern sortieren wollen und die ursprünglichen Feldwerte unberührt lassen, dass durch den Vergleich der dereferenced Werte als auch getan werden, aber dann tauschen nur die Zeiger:

int i, j, *swap; 
... 
for (i = 0; i < MAXI - 1; i++) {  /* sort pointer array */ 
    for (j = 0; j < MAXI - i - 1; j++) { 
     /* For decreasing order use < */ 
     if (*(arrp[j]) > *(arrp[j + 1])) { /* compare values */ 
      swap = arrp[j];    /* swap pointers */ 
      arrp[j] = arrp[j + 1]; 
      arrp[j + 1] = swap; 
     } 
    } 
} 

printf ("\nsorted array - by pointers\n\n"); 
for (i = 0; i < MAXI; i++) { 
    if (i && !(i % 10)) putchar ('\n'); 
    printf (" %4d", *(arrp[i])); 
} 
putchar ('\n'); 

printf ("\noriginal array\n\n"); 
for (i = 0; i < MAXI; i++) { 
    if (i && !(i % 10)) putchar ('\n'); 
    printf (" %4d", arr[i]); 
} 
putchar ('\n'); 

Drucken mit Die Zeiger geben die gleiche sortierte Reihenfolge, aber das direkte Drucken der Array-Werte liefert das ursprüngliche unsortierte Array. z.B.: In Funktion

$ sorted array - by pointers 

-100 -99 -98 -98 -97 -95 -93 -93 -92 -86 
    -86 -84 -81 -75 -73 -72 -67 -65 -64 -63 
    -62 -59 -55 -53 -53 -52 -50 -48 -46 -42 
    -40 -40 -37 -32 -31 -31 -28 -28 -27 -23 
    -21 -20 -20 -17 -11 -9 -8 -6 -4 -4 
    -1 -1 0 2 6 18 21 22 22 23 
    24 26 26 28 29 33 34 34 34 36 
    39 42 43 43 52 58 58 61 62 65 
    67 70 70 73 79 80 80 80 80 81 
    82 89 89 90 92 92 94 97 98 100 

original array 

    80 -99 21 -98 -63 -52 -59 -73 -75 2 
    -62 -53 -31 92 -31 -98 -32 36 -27 -28 
    -21 22 -6 -53 92 29 100 97 -40 -86 
    -64 90 -84 58 43 -97 -95 34 81 82 
    -65 -81 79 -46 61 98 -93 -72 -17 -20 
    0 62 52 94 -92 43 22 58 -11 33 
    73 26 -28 89 -67 -86 42 89 -1 23 
    70 34 -8 -1 39 -48 -4 -4 -20 80 
    26 80 -9 -23 24 -50 70 -55 -93 -42 
    28 80 34 -100 18 67 65 -40 6 -37 

Sie müssen Array-of-Pointers Pass von Pointer auf Sortieren

Ein weiteres Problem mit Ihrer Funktion Sie einen Zeiger (ein Array von int) sind vorbei, aber um Sortieren nach Zeiger-Array, müssen Sie ein Array von Zeigern an die Sortierfunktion übergeben (zB pointer-to-pointer-to-int). Um in einer Funktion nur die Zeiger-Array zu sortieren, während das ursprüngliche Array unverändert zu lassen, können Sie die folgende verwenden:

/* sort an array of 'n' pointers to int in 'a' */ 
void psort (int **a, int n) 
{ 
    int i, j, *swap; 

    for (i = 0; i < n - 1; i++) {  /* sort pointer array */ 
     for (j = 0; j < n - i - 1; j++) { 
      /* For decreasing order use < */ 
      if (*(a[j]) > *(a[j + 1])) { /* compare values  */ 
       swap = a[j];    /* swap only pointers */ 
       a[j] = a[j + 1]; 
       a[j + 1] = swap; 
      } 
     } 
    } 
} 

Dann in dem obigen Beispiel würden Sie die Art in main() mit ersetzen:

psort (arrp, MAXI); 

Dies würde zu den gleichen Ergebnissen führen, die oben für den Fall des Nur-Sortier-Zeigers angegeben wurden.

Answer 3

Die Art, wie Sie das Array in das Array von Zeigern kopieren, ist falsch. Dies ist der richtige Weg:

for (i = 0; i < SIZE; i++) 
    sortAr[i] = &ptr[i]; 

Und wenn Sie den Inhalt des Arrays von Zeigern vergleichen zu können, sollten Sie diese Syntax verwendet werden

if (*sortAr[j] > *sortAr[j + 1]) { ... } 

Das gleiche gilt für, wenn Sie den Inhalt drucken

for (z = 0; z < SIZE; z++) 
    printf("%d\t", *sortAr[z]);