在C语言中，如何对一个指针数组进行排序，其中每个指针都指向一个可变长度的int数组? [英] In C, how to sort an array of pointers where each pointer points to a variable-length array of int?

问题描述

我的问题是如何按所有其他数组中的第一个数字对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");
    }
}

解决方案

如评论中所述，主要答案是谨慎".问题本身并没有说明对数组的内容进行排序.但是，其中一项评论中提到了这一点.这是使用标准库函数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 

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

My question is how to sort the arr6 by the first num in all other array. I mean, if arr1 have 3 in the first num, that means it needs to be 3 in arr6. In the end, arr6 needs to point in first place to 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");
    }
}

解决方案

As noted in the comments, the main answer is 'carefully'. The question itself doesn't say anything about sorting the content of the arrays. However, that is mentioned in one of the comments. Here's code that does the job, using the standard library function qsort() — twice. I extended the list of arrays a bit, and renamed arr6 to list to separate it from the other arrN arrays (and there is probably a better name for it than list — be my guest).

I called this 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");
    }
}

When compiled and run, it produces:

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 

The version commented out with #if 0 … #endif does a more complicated comparison. It sorts the arrays so that the ones with the smallest numbers at the start of the array appear first, and then for those arrays which have a common subset, the shorter array comes before the longer:

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 

This was why the extra entries with near identical contents were added.

这篇关于在C语言中，如何对一个指针数组进行排序，其中每个指针都指向一个可变长度的int数组?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！