在C中，如何对每个指针指向一个int变长数组的指针数组进行排序？

Question

我的问题是如何排序arr6所有其他数组中的第一个数字。 我的意思是，如果arr1在第一个num中有3个，这意味着它需要在arr6中为3。 最后，arr6需要首先指向arr3,arr4,arr2,arr1,arr5。

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

void sort_arr(int **arr6); 
void print_arr(int **arr6); 
void order_arr(int **arr6); 

int main(void) 
{ 
    int i = 1; 
    int arr1[] = { 3, 9, 6, 7 }; 
    int arr2[] = { 2, 5, 5 }; 
    int arr3[] = { 0 }; 
    int arr4[] = { 1, 6 }; 
    int arr5[] = { 4, 5, 6, 2, 1 }; 
    int* arr6[] = { arr1, arr2, arr3, arr4, arr5 }; 
    printf("Printing: \n"); 
    print_arr(&arr6); 
    sort_arr(&arr6); 
    printf("Sorted rows\n"); 
    print_arr(&arr6); 
    printf("Ordered array:\n"); 
    order_arr(&arr6); 
    system("PAUSE"); 
    return 0; 
} 


void sort_arr(int **arr6) 
{ 
    int c = 0, d = 0,k = 0, swap = 0; 
    for (k; k < sizeof(arr6)+1; k++) 
    { 
     for (c = 1; c < (arr6[k][0] + 1); c++) 
     { 
      for (d = 1; d < arr6[k][0]; d++) 
      { 
       if (arr6[k][d] > arr6[k][d + 1]) 
       { 
        swap = arr6[k][d]; 
        arr6[k][d] = arr6[k][d + 1]; 
        arr6[k][d + 1] = swap; 
       } 
      } 
     } 
    } 
} 


void print_arr(int **arr6) 
{ 
    int c = 0, k = 0; 
    for (k = 0; k < sizeof(arr6) + 1; k++) 
    { 
     for (c = 1; c < (arr6[k][0] + 1); c++) 
     { 
      printf("%d ", arr6[k][c]); 
     } 
     printf("\n"); 
    } 
} 

Answer 1

正如评论中指出的那样，主要答案是“小心”。这个问题本身并没有说明如何排序数组的内容。但是，其中一条评论提到了这一点。这是使用标准库函数qsort()来完成这项工作的代码 - 两次。我稍微扩展了阵列列表，并将其更名为arr6至list，以将它与其他arrN阵列分开（并且可能比list更适合作为我的客户）。

我叫这个qs79.c：

/* SO 4335-0957 */ 
#include <stdio.h> 
#include <stdlib.h> 

void sort_arr(int num, int **list); 
void print_arr(int num, int **list); 

int main(void) 
{ 
    int arr1[] = { 3, 9, 6, 7 }; 
    int arr2[] = { 2, 5, 5 }; 
    int arr3[] = { 0 }; 
    int arr4[] = { 1, 6 }; 
    int arr5[] = { 4, 5, 6, 2, 1 }; 
    int arr6[] = { 4, 2, 7, 1, 5 }; 
    int arr7[] = { 4, 2, 5, 1, 6 }; 
    int arr8[] = { 9, 12, 19, 18, 10, 28, 27, 15, 15, 27 }; 
    int arr9[] = { 4, 2, 5, 1, 5 }; 

    int *list[] = { arr1, arr2, arr3, arr4, arr5, arr6, arr7, arr8, arr9 }; 
    enum { NUM_LIST = sizeof(list)/sizeof(list[0]) }; 

    printf("Unsorted:\n"); 
    print_arr(NUM_LIST, list); 
    sort_arr(NUM_LIST, list); 
    printf("Sorted:\n"); 
    print_arr(NUM_LIST, list); 
    return 0; 
} 

static int cmpintasc(const void *v1, const void *v2) 
{ 
    int i1 = *(int *)v1; 
    int i2 = *(int *)v2; 
    return (i1 > i2) - (i1 < i2); 
} 

#if 0 
static inline int min(int x, int y) { return (x < y) ? x : y; } 

static int cmpintptrasc(const void *v1, const void *v2) 
{ 
    int *i1 = *(int **)v1; 
    int *i2 = *(int **)v2; 
    int max = min(i1[0], i2[0]) + 1; 
    for (int i = 1; i < max; i++) 
    { 
     if (i1[i] != i2[i]) 
      return (i1[i] > i2[i]) - (i1[i] < i2[i]); 
    } 
    return (i1[0] > i2[0]) - (i1[0] < i2[0]); 
} 
#endif 

static int cmpintptrasc(const void *v1, const void *v2) 
{ 
    int *i1 = *(int **)v1; 
    int *i2 = *(int **)v2; 
    return (i1[0] > i2[0]) - (i1[0] < i2[0]); 
} 

void sort_arr(int num, int **list) 
{ 
    /* Sort each array in turn */ 
    for (int k = 0; k < num; k++) 
     qsort(&list[k][1], list[k][0], sizeof(list[k][0]), cmpintasc); 
    /* Sort the whole list */ 
    qsort(list, num, sizeof(list[0]), cmpintptrasc); 
} 

void print_arr(int num, int **list) 
{ 
    for (int k = 0; k < num; k++) 
    { 
     printf("%d: [%d] ", k, list[k][0]); 
     for (int c = 1; c < (list[k][0] + 1); c++) 
      printf("%d ", list[k][c]); 
     printf("\n"); 
    } 
} 

编译和运行之后，它产生：

Unsorted: 
0: [3] 9 6 7 
1: [2] 5 5 
2: [0] 
3: [1] 6 
4: [4] 5 6 2 1 
5: [4] 2 7 1 5 
6: [4] 2 5 1 6 
7: [9] 12 19 18 10 28 27 15 15 27 
8: [4] 2 5 1 5 
Sorted: 
0: [0] 
1: [1] 6 
2: [2] 5 5 
3: [3] 6 7 9 
4: [4] 1 2 5 5 
5: [4] 1 2 5 6 
6: [4] 1 2 5 7 
7: [4] 1 2 5 6 
8: [9] 10 12 15 15 18 19 27 27 28 

与#if 0注释掉版本... #endif做更复杂对比。因此，与在阵列的开始的最小号码的人首先出现它排序数组，然后对于那些有共同的子阵列，较短的阵列来之前的时间越长：

Unsorted: 
0: [3] 9 6 7 
1: [2] 5 5 
2: [0] 
3: [1] 6 
4: [4] 5 6 2 1 
5: [4] 2 7 1 5 
6: [4] 2 5 1 6 
7: [9] 12 19 18 10 28 27 15 15 27 
8: [4] 2 5 1 5 
Sorted: 
0: [0] 
1: [4] 1 2 5 5 
2: [4] 1 2 5 6 
3: [4] 1 2 5 6 
4: [4] 1 2 5 7 
5: [2] 5 5 
6: [1] 6 
7: [3] 6 7 9 
8: [9] 10 12 15 15 18 19 27 27 28 

这就是为什么添加了几乎相同内容的额外条目。