C 按升序打印不同类型的多个数组

我想根据

numbers\u column3

值按升序打印多个不同类型的数组。我有两个指针数组和一个浮点数组。我希望它们像excel文档一样分组在一起，第一行是a1、a2和a3。每列有三个数组。我展示的代码只是一个简单的示例。目前，我的数组中大约有20k个值。有没有办法避免典型的泡沫类型？这将需要大量的malloc和strcpy操作

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

int main(int argc, char **argv)
{
    char *q6_tag_strings_line_column1[2000] = {0};
    char *q6_nationality_strings_line_column2[2000] = {0};
    float numbers_column3[2000] = {0};

    q6_tag_strings_line_column1[0] = 
    malloc(strlen("echo")+1);

    strcpy(q6_tag_strings_line_column1[0], 
    "echo");

    q6_nationality_strings_line_column2[0] = 
    malloc(strlen("hi")+1);

    strcpy(q6_nationality_strings_line_column2[0], 
    "hi");

    numbers_column3[0] = 5;

    q6_tag_strings_line_column1[1] = 
    malloc(strlen("how")+1);

    strcpy(q6_tag_strings_line_column1[1], 
    "how");

    q6_nationality_strings_line_column2[1] = 
    malloc(strlen("are")+1);

    strcpy(q6_nationality_strings_line_column2[1], 
    "are");

    numbers_column3[1] = 7;


    q6_tag_strings_line_column1[2] = 
    malloc(strlen("you")+1);

    strcpy(q6_tag_strings_line_column1[2], 
    "you");

    q6_nationality_strings_line_column2[2] = 
    malloc(strlen("what")+1);

    strcpy(q6_nationality_strings_line_column2[2], 
    "what");

    numbers_column3[1] = 4;
    return 0;
}

---

如果三个数组的元素在语义上是耦合的，为什么不创建一个带有

标记

、

国籍

和

编号

字段的

结构

。这使得数据元素之间的连接更加明确，并允许使用标准库

qsort（）

函数创建和排序此类结构的数组。以下是一个示例程序：

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

struct Data {
    char *tag;
    char *nationality;
    float number;
};

int compare_Data(const void *a, const void *b);

int main(void)
{
    struct Data my_data[] = {
        { .tag = "North America",
          .nationality = "Canadian",
          .number = 3.3 },
        { .tag = "South America",
          .nationality = "Brazilian",
          .number = 5.5 },
        { .tag = "Asia",
          .nationality = "Japanese",
          .number = 1.1 },
    };

    puts("Before sorting:");
    for (size_t i = 0; i < sizeof my_data / sizeof *my_data; i++) {
        printf("Number:      %f\n"
               "Nationality: %s\n"
               "Tag:         %s\n",
               my_data[i].number,
               my_data[i].nationality,
               my_data[i].tag);
        putchar('\n');
    }

    qsort(my_data,
          sizeof my_data / sizeof *my_data,
          sizeof *my_data,
          compare_Data);

    puts("After sorting:");
    for (size_t i = 0; i < sizeof my_data / sizeof *my_data; i++) {
        printf("Number:      %f\n"
               "Nationality: %s\n"
               "Tag:         %s\n",
               my_data[i].number,
               my_data[i].nationality,
               my_data[i].tag);
        putchar('\n');
    }
    return 0;
}

int compare_Data(const void *a, const void *b)
{
    const struct Data *da = (const struct Data *) a;
    const struct Data *db = (const struct Data *) b;

    return (da->number > db->number) - (da->number < db->number);
}

---

我认为如果您将column3的索引存储在另一个数组中，那么您可以按照索引打印列。 对于eg-在第3列排序期间，按如下方式存储索引，以便

---

新数组包含[2,0,1]

为什么不使用带有

标记的
结构
、
国籍
和
数字
字段，然后使用
qsort（）
对这些结构的数组排序？如果您还没有了解结构，那么“并行数组”就是您必须使用的。如果你已经了解了结构，就使用它们；这将使生活更轻松。此外，如果您的计算机上没有可用的
strdup（）
，请编写自己的版本并使用它。它大大减少了代码。（extern char*strdup（const char*str）；char*strdup（const char*str）{size\u t len=strlen（str）+1；char*rv=malloc（len）；if（rv！=0）memmove（rv，str）；return rv；}`（如果
malloc（）
失败，您甚至可以决定中止或退出，这意味着您不必检查错误返回。）@JonathanLeffler我大概在10年前学会了结构，一年最多只使用一次，所以我对它们的记忆非常模糊。我能用最少的问题大致理解戴维斯。谢谢你提供了一个例子。我开始在谷歌上搜索一些例子。结构听起来会让生活更轻松。@noobprogrammer1987--这听起来像是
struct
s所擅长的那种东西，而且库
qsort（）
函数效率很高，而且已经编写好了；）你能帮我刷新一些东西吗？在
.tag=“North America”
中，什么是
？这对我的数据大小有什么作用？在
qsort（）
的第三部分执行
sizeof*my_data
而不是
sizeof my_data
是否更好？我在看一个例子，他们是用什么方法做的。@noobprogrammer1987--
.tag
是指定初始值设定项语法的一部分。这允许您指定要初始化的字段
sizeof my_data
生成数组的大小
my_data[]
以字节为单位，而
sizeof*my_data
生成数组第一个元素的大小。因此，
sizeof my_data/sizeof*my_data
将生成数组中的元素数。谢谢。我试着做一个小例子来了解这一点。现在效果很好。
#include <stdio.h>
#include <stdlib.h>

struct Data {
    char *tag;
    char *nationality;
    float number;
};

int compare_Data(const void *a, const void *b);

int main(void)
{
    struct Data my_data[] = {
        { .tag = "North America",
          .nationality = "Canadian",
          .number = 3.3 },
        { .tag = "South America",
          .nationality = "Brazilian",
          .number = 5.5 },
        { .tag = "Asia",
          .nationality = "Japanese",
          .number = 1.1 },
    };

    puts("Before sorting:");
    for (size_t i = 0; i < sizeof my_data / sizeof *my_data; i++) {
        printf("Number:      %f\n"
               "Nationality: %s\n"
               "Tag:         %s\n",
               my_data[i].number,
               my_data[i].nationality,
               my_data[i].tag);
        putchar('\n');
    }

    qsort(my_data,
          sizeof my_data / sizeof *my_data,
          sizeof *my_data,
          compare_Data);

    puts("After sorting:");
    for (size_t i = 0; i < sizeof my_data / sizeof *my_data; i++) {
        printf("Number:      %f\n"
               "Nationality: %s\n"
               "Tag:         %s\n",
               my_data[i].number,
               my_data[i].nationality,
               my_data[i].tag);
        putchar('\n');
    }
    return 0;
}

int compare_Data(const void *a, const void *b)
{
    const struct Data *da = (const struct Data *) a;
    const struct Data *db = (const struct Data *) b;

    return (da->number > db->number) - (da->number < db->number);
}