c - 如何在C中对字符串数组与整数数组并行排序？没有结构体？

Question

好吧，年龄的冒泡排序是有效的。我现在遇到麻烦的部分是全名的冒泡排序，这需要首先发生。我考虑过将排序后的年龄暂时存储在数组中，但我想这是作弊。我需要数据输入，打印未排序的姓名和年龄，排序名称，打印排序的名称未排序的年龄，排序年龄，并打印排序的名称和年龄...

我该怎么办？

1. 成功对字符串数组进行排序？
2. 使用相应的字符串保留适当的年龄？

3. 打印排序后的字符串而不同时对年龄和字符串进行排序？

   #define SIZE 5
   #include <stdio.h>
   #include <string.h>
   #include <stdio.h>
   
   
   void input(char fullname[][25], int age[]);
   void output(char fullname[][25], int age[]);
   //int compare(int x, int y);
   void bubbleSortage(int * const array,const int size);
   
   int main(int argc, char *argv[]) 
   {
       char fullname[SIZE][25];
       int age[SIZE];
       int unneccessayalternateagearraybecausewehavetoprintthesortedvaluestwice[SIZE];
   
       // prompt user for names and ages
       input(fullname, age);
       //output unsorted names and ages
       output(fullname, age);
   
       bubblesortname(fullname,SIZE);
   
       output(fullname, age);
   
       //sorts age
       bubbleSortage(age,SIZE);
       //
       output(fullname, age);
   
   
       return 0;
   }
   
   void input(char fullname[][25], int age[]) 
   {
       int i;
       for (i = 0; i < SIZE; i++) 
       {
           fflush(stdin);
           printf("Enter a full name\n");
           //scanf("%[\^n]\n", fullname[i]);
           fgets (fullname[i],40, stdin);
           printf("Enter the age\n");
           scanf("%d", &age[i]);
   
       }
   }
   
   void output(char fullname[][25], int age[]) 
   {
       int i;
       for (i = 0; i < SIZE; i++)
           printf("%s, %d\n", fullname[i], age[i]);
   }//end function
   
   void bubblesortname(int * const array, const int size)
   {
       int i, j;
   
   
       for (j = 0; j < size -1; j++) 
       {
           for (i = 0; i < size -1; i++) 
             {
               if (0<strcmp(fullname[i + 1], fullname[i]))
                {
                   char *temp = fullname[i];
                   fullname[i]= fullname[i+1];
                   fullname[i+1]= tmp;
   
   
                }//end if
   
           }//end inner for
   
       }//end for
   
   }//end function
   
   void bubbleSortage(int * const array, const int size)
   {
       void swap(int *element1Ptr, int *element2Ptr );
       int pass; //pass counter
       int j; // comparison counter
   
       //loop to control passes
       for(pass = 0;pass < size -1; pass++)
       {
           //loop to control comparison each pass
           for(j=0; j<size - 1;j++)
           {
               //swap elements if they are not in order
               if(array[j]>array[j+1])
               {
                   swap(&array[j], &array[j+1]);
               }// end if
   
           }// end inner for
   
       }// end outer for
   
   
   }// end function
   
   //swap values at memory locations to 1Ptr and 2 Ptr
   void swap(int *element1Ptr, int *element2Ptr)
   {
       int hold = *element1Ptr;
       *element1Ptr = *element2Ptr;
       *element2Ptr = hold;
   }// end swap function
   

完整内容将存储在字符串数组，二维字符数组。年龄将存储在整数数组。 将阵列作为并行阵列进行管理。数据输入将来自键盘，将读取全名，然后是年龄。数据输入将终止当数组已满或未输入全名时。使用子程序来输入数据并将数组传递给子程序，不要使用全局数组。一旦数据完全输入后，使用另一个子例程将数组打印到屏幕上。然后使用子例程对全名数据进行升序排序。重复使用打印件子例程并将排序后的数据打印到屏幕上。编写另一个子程序将年龄数据作为主要排序，将全名作为次要排序。最后重用打印子例程将数据打印到屏幕上。主程序会调用数据输入函数、打印函数、名称排序函数、打印函数函数，年龄排序函数，最后是打印函数。所有数据将被传递到功能，无全局数据

**** 更新的代码 ************

    #define SIZE 5
    #include <stdio.h>
    #include <string.h>
    #include <stdio.h>


    void input(char fullname[][25], int age[]);
    void output(char fullname[][25], int age[]);
    void bubblesortname(char *fullname[], int *age, SIZE size);
    bubblesortage(char *fullname[], int *age, SIZE size);

    int main(int argc, char *argv[]) 
    {
        char fullname[SIZE][25];
        int age[SIZE];
        char *tmp;


        // promt user for names and ages
        input(fullname, age);
        //output unsorted names and ages
        output(fullname, age);

        bubblesortname(fullname,age,SIZE);

        output(fullname, age);

        //sorts age
        bubbleSortage(fullname,age,SIZE);
        //
        output(fullname, age);


        return 0;
    }

    void input(char fullname[][25], int age[]) 
    {
        int i;
        for (i = 0; i < SIZE; i++) 
        {
            fflush(stdin);
            printf("Enter a full name\n");
            //scanf("%[\^n]\n", fullname[i]);
            fgets (fullname[i],40, stdin);
            printf("Enter the age\n");
            scanf("%d", &age[i]);

        }
    }

    void output(char fullname[][25], int age[]) 
    {
        int i;
        for (i = 0; i < SIZE; i++)
            printf("%s, %d\n", fullname[i], age[i]);
    }//end function

    void bubblesortname(char *fullname[], int *age, SIZE size)
    {
         int temp_age;
          char* temp_name;
          int n;

          for (SIZE pass = 0; pass < size - 1; ++pass) 
          {
            for (SIZE n = 0; n < len - 1; ++n) 
            {
              if (strcmp(fullname[n], fullname[n + 1]) > 0) 
              {
                temp_age = age[n];
                age[n] = age[n + 1];
                age[n + 1] = temp_age;

                temp_name = fullname[n];
                fullname[n] = fullname[n + 1];
                fullname[n + 1] = temp_name;


                 }//end if

            }//end inner for

        }//end for

    }//end function

            bubblesortage(char *fullname[], int *ages, SIZE size) 
            {
                int n;
                int temp_age;
                char* temp_name;
                    for (SIZE pass = 0; pass < size - 1; ++pass) 
                      {
                         for (SIZE n = 0; n < size - 1; ++n) 
                            {
                                 if (age[n] > age[n + 1]) 
                                  {

                                    temp_age = age[n];
                                    age[n] = age[n + 1];
                                    age[n + 1] = temp_age;
                                    temp_name = fullname[n];
                                    fullname[n] = fullname[n + 1];
                                    fullname[n + 1] = temp_name;

                                    }// end inner for

                            }// end outer for


                        }// end function

Answer 1

显然，您需要并行管理数组。根据我原来的答案，使用结构会更好。

但你不能。所以，你必须有两个数组。原理还是一样的，只是有点困惑。使用strcmp比较姓名字符串，并手动比较年龄。

现在，从技术上讲，您的规范要求两个排序子例程。这意味着您将有一个用于年龄的对象，用于对 int 数组进行排序，另一个用于名称的对象，用于对 char* 数组进行排序。

对整数进行排序(请注意，这遵循您的排序算法，实际上不是 bubble sort ):

void bubble_sort_age(int *arr, size_t len) {
  int temp;
  for (size_t pass = 0; pass < len - 1; ++pass) {
    for (size_t n = 0; n < len - 1; ++n) {
      if (arr[n] > arr[n + 1]) {
        // write a swap function if you really want to
        temp = arr[n];
        arr[n] = arr[n + 1];
        arr[n + 1] = temp;
      }
    }
  }
}

请注意，我使用 size_t 类型作为数组索引计数器，因为它保证对于任何数组来说都足够大。

就我个人而言，我可能会使用 unsigned int 类型来表示年龄，因为年龄为负数的人没有多大意义。

这是同样的事情，但在字符串上使用 strcmp:

void bubble_sort_name(char *arr[], size_t len) {
  char* temp;
  for (size_t pass = 0; pass < len - 1; ++pass) {
    for (size_t n = 0; n < len - 1; ++n) {
      if (strcmp(arr[n], arr[n + 1]) > 0) {
        temp = arr[n];
        arr[n] = arr[n + 1];
        arr[n + 1] = temp;
      }
    }
  }
} 

这还不够，因为我们需要确保排序时姓名和年龄对保持在一起......所以每当我们排序时，我们都会传入两个数组，每当我们交换时，我们都会将交换应用于...两个数组。

现在，如果我们把它们放在一起，它将看起来像这样:

// swap BOTH name and age to keep the arrays in sync =)
void bubble_sort_name(char *names[], int *ages, size_t len) {
  int temp_age;
  char* temp_name;
  for (size_t pass = 0; pass < len - 1; ++pass) {
    for (size_t n = 0; n < len - 1; ++n) {
      if (strcmp(names[n], names[n + 1]) > 0) {
        temp_age = ages[n];
        ages[n] = ages[n + 1];
        ages[n + 1] = temp_age;

        temp_name = names[n];
        names[n] = names[n + 1];
        names[n + 1] = temp_name;
      }
    }
  }
}

void bubble_sort_age(char *names[], int *ages, size_t len) {
  int temp_age;
  char* temp_name;
  for (size_t pass = 0; pass < len - 1; ++pass) {
    for (size_t n = 0; n < len - 1; ++n) {
      if (ages[n] > ages[n + 1]) {
        // write a swap function if you really want to
        temp_age = ages[n];
        ages[n] = ages[n + 1];
        ages[n + 1] = temp_age;

        temp_name = names[n];
        names[n] = names[n + 1];
        names[n + 1] = temp_name;
      }
    }
  }
}

void print(char *names[], const int *ages, size_t len) {
  for (size_t n = 0; n < len; ++n) {
    printf("%s %d\n", names[n], ages[n]);
  }
}

int main(void) {
  // Input &c omitted.
  // If you don't know how to malloc/realloc and read input,
  // there should be plenty of other SO questions showing how

  int ages[N_ITEMS] = { -10, 2, -1, -10, 0xDEADBEEF };
  char *names[] = { "one", "two", "-1", "onf", "foo" };

  print(names, ages, N_ITEMS);
  printf("\n");

  bubble_sort_name(names, ages, N_ITEMS);
  print(names, ages, N_ITEMS);
  printf("\n");

  bubble_sort_age(names, ages, N_ITEMS);
  print(names, ages, N_ITEMS);

  return 0;
}

---

由于您需要对姓名、打印进行排序，然后对年龄进行主要排序，但对年龄进行二次排序，因此我们可以利用冒泡排序的功能。

这是一个 stable sort ，因此当我们根据不同的标准对数组进行排序时，相等的元素(在新的排序顺序下)将保持与旧排序相同的顺序(相对于彼此)。

这意味着我们第二次可以简单地按年龄排序，只要我们记住姓名和年龄都必须重新排列，这就是我们需要做的:)

---

专家额外提示:您实际上可以重写冒泡排序方法，以便可以对字符串和 int 重用它。您可以使用 void * 和强制类型转换来做到这一点。不过，使用结构类型会更好。