En C, comment sortinger un tableau de pointeurs où chaque pointeur pointe vers un tableau de longueur variable de int?

Ma question est de savoir comment sortinger l’ arr6 par le premier nombre de tous les autres tableaux. Je veux dire, si arr1 a 3 dans le premier num , cela signifie qu’il doit être 3 dans arr6 . À la fin, arr6 doit indiquer en premier lieu arr3 , arr4 , arr2 , arr1 , arr5 .

 #include  #include  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][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"); } } 

Comme indiqué dans les commentaires, la réponse principale est «soigneusement». La question elle-même ne dit rien sur le sorting du contenu des tableaux. Cependant, cela est mentionné dans l’un des commentaires. Voici le code qui fait le travail, en utilisant la fonction de bibliothèque standard qsort() – deux fois. J’ai rallongé un peu la liste des tableaux et renommé arr6 en list pour le séparer des autres tableaux arrN (et son nom est probablement meilleur que celui de list – soyez mon invité).

J’ai appelé ce qs79.c :

 /* SO 4335-0957 */ #include  #include  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"); } } 

Une fois compilé et exécuté, il produit:

 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 

La version commentée avec #if 0#endif fait une comparaison plus compliquée. Il sortinge les tableaux de sorte que ceux avec les plus petits nombres au début du tableau apparaissent en premier, puis pour les tableaux qui ont un sous-ensemble commun, le tableau le plus court précède le plus long:

 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 

C'est pourquoi les entrées supplémentaires avec un contenu presque identique ont été ajoutées.