读取文本文件，将每一行分成单独的数组，然后在C中排序

Question

I am trying to write a program that reads a text file and breaks each line into separate arrays so they can be sorted by date and name. I am still having trouble getting the 'sort by date' function to work/display properly, which is why I haven't attempted the sort by name function yet.

I seem to be able to scan in the date and name arrays fine, but I think I need to modify the way I scan in the last array 'dates' because I need to separate them with a space after a comma. Problem is that I am not sure how to scan them in as a string seeing as they would have spaces between them and some names have different numbers of states. (I removed the spaces between the states in the text file at this point, but the text file needs to have them back in probably?)

My code so far...

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

#define MAX 30

void sortByDate( int year[], char *name[], char *states[], int count);
void sortByName(int year[], char name[], char states[], int count);

int main()
{
     int year[MAX]; 
     int i, a;
     int count = 0;
     int choice;
     char *name[MAX],
          *states[MAX];
     char b[MAX], c[MAX];

     FILE *inp = fopen("hurricanes.txt","r");               /* defining file input    */

     for(i=0;i<MAX;i++)
     {
         if( feof(inp) )
        {
            break;
        } 
        fscanf(inp, "%d", &a);
        fscanf(inp, "%s", &b);
        fscanf(inp, "%s", &c);
        year[i]=a;
        strcpy(&name[i],b);
        strcpy(&states[i],c);
        ++count; 

        printf("%d %s %s\n", year[i], &name[i], &states[i]);
     }

     printf("Press 0 to sort by date or 1 to sort by name: ");
     scanf("%d", &choice);  
     if (choice == 0)
     {
         sortByDate(year, name, states, count); 
     }
     else if ( choice == 1)
     {
          //sortByName(year, name, states, count); 
     }

     getch();
     return 0;
}

void sortByDate( int year[], char *name[], char *states[], int count )
{
     int d = 0;
     int c = 0;

     int yearTmp;
     char nameTmp[MAX], statesTmp[MAX];
     int order[count];
     int tmp = 0;

     FILE *outp = fopen("report.txt","w");                 /* defining file output   */

     for (c = 0; c < count; ++c)
     {
         order[c] = c; 
     } 

     for (c = 0 ; c < ( count - 1 ); c++)
     {
          for (d = 0 ; d < count - c - 1; d++)
          {
               if (year[d] > year[d+1])
               {
                    yearTmp = year[d];
                    year[d] = year[d+1]; 
                    year[d+1] = yearTmp; 

                    tmp = order[d];
                    order[d] = order[d+1];
                    order[d+1] = tmp;   
              }
          }
     }

     for (c = 0; c < count; ++c)
     {
          printf("%d %-10s %s\n",  year[c], &name[order[c]], &states[order[c]]); 
     } 
}

//void sortByName(int year[], char name[], char states[], int count)
//{
//} 

The hurricanes.txt file....(again, I have removed the spaces between states but I think they need to be put back in and scanned differently?)

1960 Donna FL,NC
1969 Camille MS
1972 Agnes FL
1983 Alicia TX
1989 Hugo SC,NC
2005 Katrina FL,LA,MS
2005 Rita TX,LA
2005 Wilma FL
2008 Ike TX
2009 Ida MS
2011 Irene NC,NJ,MA,VT
2012 Isaac LA
1992 Andrew FL,LA
1995 Opal FL,AL
1999 Floyd NC
2003 Isabel NC,VA
2004 Charley FL,SC,NC
2004 Frances FL
2004 Ivan AL
2004 Jeanne FL

Ok, So I made some changes from the suggestions posted here and they worked out great!

Answer 1

Rather than storing the values in separate arrays, there may be a better approach. Anytime you are faced with sorting data that consists of multiple, related values, you should be thinking struct . That is the mechanism in C that provides a way to correlate a sort across data comprised of multiple variables.

For example, in your case you have (1) the year , (2) the hurricane name , and (3) the hurricane path through states that all represent a single event. When you have data that consists of multiple events that you want to sort by either year , name or path , you need a way to preserve the correlation between which name occurred which year and took what path. A simple structure such as the following will do

typedef struct {
    unsigned year;
    char name[MAXC];
    char path[MAXC];
} hcdata;

In your program, you can then declare and array of type hcdata and fill the array with data read from your file. While you will generally want to read a line at a time with the line-oriented input functions ( fgets or getline ), when you have the exact same format of information on each line, the scanf family of functions can provide an realistic alternative. (it is one of the limited time scanf is a realistic alternative to fgets , etc..)

To make your read with fscanf work properly, you should account for each character in the line being read (including the '\\n' ). While reading integer values will skip intervening whitespace, if you get in the habit of accounting for each character, you won't be surprised when your next line begins with a character. In this case you can use a format-string of:

    char *fmt = "%u %31[^ ] %31[^\n]%*c";

Lastly, qsort is the default standard way to sort data in the the C library. It is optimized with several differing sort methods that are optimized for large/small datasets that work together to produce a blistering fast sort. All you need to do is write compare functions to pass to qsort . With the struct above, to sort on either name or year , the compare functions are almost trivial. For example,

int cmpname (const void *a, const void *b)
{   return strcmp (((hcdata *)a)->name, ((hcdata *)b)->name); }

int cmpyear (const void *a, const void *b)
{   return ((hcdata *)a)->year - ((hcdata *)b)->year; }

You can use as simple a sort function as is necessary, or you can tailor the sort to sort on secondary parameters in the event there is no difference between primary values. For example, sort alphabetically by name if the year is the same:

int cmpyear (const void *a, const void *b)
{   
    int diff = ((hcdata *)a)->year - ((hcdata *)b)->year;

    if (diff > 0)   /* if years differ, sort by year */
        return 1;
    else if (diff < 0)
        return -1;

    /* otherwise sort alphabetically with same year */
    return strcmp (((hcdata *)a)->name, ((hcdata *)b)->name);
}

Sorting then becomes as simple as a single call, eg:

    qsort (hcd, idx, sizeof *hcd, cmpname);

Putting all of the pieces together, you can read your data, sort by name and then sort again by year in a straightforward manner:

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

enum { MAXC = 32, MAXL = 128 };

typedef struct {
    unsigned year;
    char name[MAXC];
    char path[MAXC];
} hcdata;

int cmpname (const void *a, const void *b);
int cmpyear (const void *a, const void *b);
void prndata (hcdata *h, size_t n);

int main (int argc, char **argv) {

    hcdata hcd[MAXL] = {{ 0, {""}, {""} }};
    size_t idx = 0;
    char *fmt = "%u %31[^ ] %31[^\n]%*c";
    FILE *fp = argc > 1 ? fopen (argv[1], "r") : stdin;

    if (!fp) {  /* validate file open for reading */
        fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
        return 1;
    }

    /* read each line of data into an array of struct */
    while (idx < MAXL && fscanf (fp, fmt,
        &hcd[idx].year, hcd[idx].name, hcd[idx].path) == 3)
        idx++;

    printf ("\noriginal file order:\n\n");
    prndata (hcd, idx);

    qsort (hcd, idx, sizeof *hcd, cmpname);    /* sort by name */
    printf ("\nsorted by hurricane name:\n\n");
    prndata (hcd, idx);

    qsort (hcd, idx, sizeof *hcd, cmpyear);    /* sort by year */
    printf ("\nsorted by year:\n\n");
    prndata (hcd, idx);

    if (fp != stdin) fclose (fp);

    return 0;
}

int cmpname (const void *a, const void *b)
{   return strcmp (((hcdata *)a)->name, ((hcdata *)b)->name); }

int cmpyear (const void *a, const void *b)
{   return ((hcdata *)a)->year - ((hcdata *)b)->year; }

void prndata (hcdata *h, size_t n)
{
    if (!h || !n) return;
    size_t i;
    for (i = 0; i < n; i++)
        printf (" y: %u    n: %-10s    p: %s\n", h[i].year,
                h[i].name, h[i].path);
}

Example Use/Output

$ ./bin/hurricanes <dat/hurricanes.txt

original file order:

 y: 1960    n: Donna         p: FL,NC
 y: 1969    n: Camille       p: MS
 y: 1972    n: Agnes         p: FL
 y: 1983    n: Alicia        p: TX
 y: 1989    n: Hugo          p: SC,NC
 y: 2005    n: Katrina       p: FL,LA,MS
 y: 2005    n: Rita          p: TX,LA
 y: 2005    n: Wilma         p: FL
 y: 2008    n: Ike           p: TX
 y: 2009    n: Ida           p: MS
 y: 2011    n: Irene         p: NC,NJ,MA,VT
 y: 2012    n: Isaac         p: LA
 y: 1992    n: Andrew        p: FL,LA
 y: 1995    n: Opal          p: FL,AL
 y: 1999    n: Floyd         p: NC
 y: 2003    n: Isabel        p: NC,VA
 y: 2004    n: Charley       p: FL,SC,NC
 y: 2004    n: Frances       p: FL
 y: 2004    n: Ivan          p: AL
 y: 2004    n: Jeanne        p: FL

sorted by hurricane name:

 y: 1972    n: Agnes         p: FL
 y: 1983    n: Alicia        p: TX
 y: 1992    n: Andrew        p: FL,LA
 y: 1969    n: Camille       p: MS
 y: 2004    n: Charley       p: FL,SC,NC
 y: 1960    n: Donna         p: FL,NC
 y: 1999    n: Floyd         p: NC
 y: 2004    n: Frances       p: FL
 y: 1989    n: Hugo          p: SC,NC
 y: 2009    n: Ida           p: MS
 y: 2008    n: Ike           p: TX
 y: 2011    n: Irene         p: NC,NJ,MA,VT
 y: 2012    n: Isaac         p: LA
 y: 2003    n: Isabel        p: NC,VA
 y: 2004    n: Ivan          p: AL
 y: 2004    n: Jeanne        p: FL
 y: 2005    n: Katrina       p: FL,LA,MS
 y: 1995    n: Opal          p: FL,AL
 y: 2005    n: Rita          p: TX,LA
 y: 2005    n: Wilma         p: FL

sorted by year:

 y: 1960    n: Donna         p: FL,NC
 y: 1969    n: Camille       p: MS
 y: 1972    n: Agnes         p: FL
 y: 1983    n: Alicia        p: TX
 y: 1989    n: Hugo          p: SC,NC
 y: 1992    n: Andrew        p: FL,LA
 y: 1995    n: Opal          p: FL,AL
 y: 1999    n: Floyd         p: NC
 y: 2003    n: Isabel        p: NC,VA
 y: 2004    n: Charley       p: FL,SC,NC
 y: 2004    n: Frances       p: FL
 y: 2004    n: Ivan          p: AL
 y: 2004    n: Jeanne        p: FL
 y: 2005    n: Katrina       p: FL,LA,MS
 y: 2005    n: Rita          p: TX,LA
 y: 2005    n: Wilma         p: FL
 y: 2008    n: Ike           p: TX
 y: 2009    n: Ida           p: MS
 y: 2011    n: Irene         p: NC,NJ,MA,VT
 y: 2012    n: Isaac         p: LA

Compare the implementation here with your approach to the storage in individual arrays, as well as your sort routines. While the code above relies on a statically declared array of structs, there is no reason you cannot dynamically declare structures as need dynamically, if you are faced with reading an unknown number. Let me know if you have additional questions.

Answer 2

If your EOL character is a \\n , you could use this:

fscanf(inp, "%d %s %29[^\n]", &a, b, c);

where 29 is MAX - 1. Replace \\n with your EOL character(s).

Please note that you don't need to pass &b, &c to fscanf since your compiler will convert b and c to &b[0] and &c[0] . Also, on printf you are passing &name[i] , wich is a char ** when your compiler is expecting a char * . You need to change &name[i] to name[i] . The same for &states[i] .