对于类，我需要在最小值和最大值之间生成一个100个整数的数组（现在工作正常），然后在一个单独的函数中，创建一个指针数组并按升序对其进行排序。
int *ptr是指向原始数组的指针，SIZE在标题中定义为100
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]);
}
我正在使用的代码在原始数组中的所有整数都是正数或负数时工作正常，但是当有混合时，它会对数组进行排序以包含asc顺序的正数，然后是所有负数。 asc命令。例如：
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
关于什么事情的任何想法？
答案 0 :(得分：4)
您已传入int的原始数组，但已将其复制到int*数组中。当您稍后比较这些时，您有未定义的行为，因为您不允许比较指针，除非它们属于来自单个分配的相同内存块。
实际发生的是指针内部为unsigned，因此您的负值变为大的正值。幸运的是，价值正在被int调用printf，因此很难看到你做了坏事（除非你读了你的编译器＆＃39}警告）。
改为声明你的数组：
int sortAr[SIZE];
答案 1 :(得分：1)
将数组复制到指针数组的方式是错误的。这是正确的方法：
for (i = 0; i < SIZE; i++)
sortAr[i] = &ptr[i];
当你比较指针数组的内容时，你应该使用这个语法
if (*sortAr[j] > *sortAr[j + 1]) { ... }
打印内容时也是如此
for (z = 0; z < SIZE; z++)
printf("%d\t", *sortAr[z]);
答案 2 :(得分：0)
您根据存储在数组中的值对数组进行排序。您当然可以使用指向引用数组中所有值的指针数组，但要使用指针数组进行排序，您必须取消引用指针，这样您实际上是基于它进行排序价值观。
例如，下面创建一个介于-100和100之间的100个值的随机数组，指定一个引用数组以引用这些值，然后使用指针数组对这些值进行排序：
#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;
}
示例使用/输出
$ ./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
仅对指针进行排序
如果您只想对指针数组进行排序并保持原始数组值不变，那么也可以通过比较解除引用的值来完成，但只能交换指针：
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');
使用指针进行打印将提供相同的排序顺序，但直接打印数组值将提供原始未排序的数组。 e.g：
$ 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
您必须传递指针数组才能按函数中的指针排序
你的函数的另一个问题是你传递一个指针（一个int数组），但是为了按指针数组排序，你必须传递一个指向sort函数的指针数组（例如指针到指针 - 到-INT）。要在保持原始数组不变的情况下仅对函数中的指针数组进行排序，可以使用以下命令：
/* 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;
}
}
}
}
然后在上面的示例中，您将main()中的排序替换为：
psort (arrp, MAXI);
这将导致上面针对仅排序指针的情况发布相同的结果。