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

Question

Ok the bubblesort for age works. The part I am having trouble with now is the bubblesort for the fullname which needs to happen first. I thought about temporarily storing the sorted ages in an array but I guess that's cheating. I need to data entry, print unsorted name and age, sort name, print sorted name unsorted age, sort age, and print sorted name and age...

How can I?

1. Sort an array of strings successfully?
2. Keep the appropriate ages with the corresponding strings?

3. Print the sorted strings without sorting the ages and strings at the same time?

    #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 

The full will be stored in an array of strings, a two dimensioned array of characters. The ages will be stored in an array of integers. Manage the arrays as parallel arrays . Data entry will be from the keyboard and will read the full name followed by the age. Data entry will terminate when the arrays are full or when nothing is entered for the full name. Use a subroutine to enter the data and pass the arrays to the subroutine, do not use global arrays. Once the data is completely entered, use another subroutine to print out the arrays to the screen. Then use a subroutine to sort the data on the full names, ascending order. Reuse the print subroutine and print the sorted data out to the screen. Write another subroutine which sorts the data on age as the primary sort and full name as the secondary sort. Finally reuse the print subroutine to print the data to the screen. The main program will call the data entry function, followed by the print function, the name sort function, the print function, the age sort function and finally the print function. All data will be passed to the functions, no global data

**** UPDATED CODE ************

    #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

I will try and address your 3 sub-questions:

1. How do I Sort an array of strings successfully?

To sort anything you need a way of comparing the individual components. To sort strings you need to be able to compare two strings and in C you do this by calling the strcmp() function.

 #include <string.h> int strcmp(const char *s1, const char *s2); int strncmp(const char *s1, const char *s2, size_t n); 

Description

The strcmp() function compares the two strings s1 and s2 . It returns an integer less than, equal to, or greater than zero if s1 is found, respectively, to be less than, to match, or be greater than s2 .

The strncmp() function is similar, except it only compares the first (at most) n bytes of s1 and s2 .

Return Value

The strcmp() and strncmp() functions return an integer less than, equal to, or greater than zero if s1 (or the first n bytes thereof) is found, respectively, to be less than, to match, or be greater than s2 .

So here's a code example that illustrates how you compare strings in C:

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

int main()
{
    const char* jenna = "Jenna";
    const char* mark  = "Mark";

    // warning: Be careful here because the order of strings matters
    //          and is directly related to the result. If you swap them
    //          the result changes sign (1 becomes -1, -1 becomes 1 and
    //          zero stays zero).
    int comparisonResult = strcmp(jenna, mark)

    if (comparisonResult < 0)
    {
        printf("%s is less than %s\n", jenna, mark);
    }
    else if (comparisonResult > 0)
    {
        printf("%s is greater than %s\n", jenna, mark);
    }
    else // We know that (comparisonResult == 0)
    {
        printf("%s is the same as %s\n", jenna, mark);
    }

With this you should be able to modify your existing algorithm for sorting ages to sort strings. Here's an example I found on Google .

2. How do I keep the appropriate ages with the corresponding strings?

To keep different data together in C you use a struct . So if you wanted to keep a name and age together you would make a datastructure along the lines of this:

struct Person {
    char* name;
    int   age;
};

int main()
{
    // The person is a datastructure containing two elements in it.
    struct Person person = { "Mark", 25 };

    // You can access each of the subcomponents of person by using the . operator like in this printf statement.
    printf("Hi, my name is %s and I'm %d years old\n", person.name, person.age);

    return 0;
}

Now it gets annoying having to type struct in front of Person every time so most people just use typedef like this:

typedef struct Person_s {
    char* name;
    int age;
} Person;

int main()
{
    Person person = { "Mark", 25 };

    printf("Hi, my name is %s and I'm %d years old\n", person.name, person.age);

    return 0;
}

3. How do I print the sorted strings without sorting the ages and strings at the same time?

The at the same time part is ambiguous, do you mean that you don't want to change the original ordering of your inputs?

In any case you have a couple options. You can either make a copy of all of your inputs and then sort the copy, by either age or name and then print the copy. Or you can sort your original data after you have printed it and its ordering no longer matters to you since you've already printed it.

Note: I'm trying to enable you to solve this problem yourself instead of just writing the code for you. I'm pretty sure this is some type of assignment/homework that you're working on and your username suggests you're new to C...

For extra points:

The typedef syntax I used in the explanation for the 2nd part I used this example:

typedef struct Person_s {
    char* name;
    int age;
} Person;

This syntax is used to say that I want to create a type called struct Person_s and here is its definition inside of the curly braces { ... definition ... } but please rename the type from struct Person_s to Person (which is the part at the end).

Perhaps a different example of how to use typedef will help:

typedef int number_type; // make an alias for int and call it number_type

// From here on, we can use number_type instead of int.

number_type main()
{
    number_type number = 7;

    printf("%d\n", number);

    return 0;
}

We did the same with the struct Person_s earlier:

typedef 
// Define the struct
struct Person_s {
    char* name;
    int age;
}
// Give it the following alias so that you can save me some typing...
Person;

Note: This is a simplification in an attempt to make it clear for a beginner, I'm glossing over some things... Go easy on me SO!

Answer 2

You're required to manage the arrays in parallel, apparently. It would be much better to use a struct, as per my original answer.

But you can't. So, you have to have two arrays. The principles are still the same, it's just a bit messier. Use strcmp to compare name strings, and compare the ages manually.

Now, technically your specification asks for two sorting subroutines. This means you'll have one for ages, which sorts an array of int , and another for names, which sorts an array of char* .

Sorting integers ( note that this follows your sorting algorithm, which isn't actually a 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;
      }
    }
  }
}

Note that I'm using the size_t type for array index counters because it is guaranteed to be large enough for any array.

Personally, I would probably use an unsigned int type to represent age, since a person with a negative age doesn't make much sense.

And here's the same thing, but using strcmp on strings:

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;
      }
    }
  }
} 

This isn't quite enough, because we need to ensure that the pairs of names and ages are kept together when we're sorting... so we pass in both arrays whenever we sort, and whenever we swap, we apply the swap to... both arrays.

Now, if we put it all together, it will look something like this:

// 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;
}

---

Since you are required to sort on name, print, and then primary sort on age but secondary sort on age, we can take advantage of a feature of bubblesort.

It is a stable sort , so when we resort an array on a different criterion, an elements that are equal (under the new sort order) will be kept in the same order (relative to each other) that the old sort sorted them in.

This means we can simply sort on age the second time, and so long as we remember that name and age both have to be rearranged, that's all we need to do :)

---

Extra for experts: you can actually rewrite the bubble sort method so that you can reuse it for both strings and int . You can do that using void * and casts. It would be much better to use a struct type, though.

Answer 3

To sort strings, use strcmp() to make the comparisons.

to also sort the alternate/parallel array, at the same time so names and ages are all sorted according to the name:

in the code that performs the swap in the bubble sort algorithm when sorting the names:

add code to also swap the associated entries in the alternate/parallel array (the ages)

this will be made much easier if the bubble sort uses array indexing rather than pointers, as the indexes would also work in the alternate/parallel array