从 C 的文件中读取多个 integer 行

Question

4
1 2 4 3 5 4 5
4 1 7 3 3
2 1 3 4 10

The first line is number of vertices.

From second line, first column, is the vertex. Next set of 'pairs' are vertex and weight respectively.

I tried just to read only first line using fscanf(fptr, "%[^\n]", vertices);which gave garbage value. vertices = fgetc(fptr); gave me a different value but not garbage (I think)

The second line onwards, I'm not sure how to add to my adj list directed graph, but I need help just to get those values.

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

int main()
{
    FILE *fptr;
    fptr = fopen("adjacencylist.txt", "r");
    if (fptr == NULL) exit(1);

    int vertices, c;
    //fscanf(fptr, "%[^\n]", vertices);
    //vertices = fgetc(fptr);
    vertices = fgetc(fptr);
    printf("%d", vertices);
    fclose(fptr);
}

Answer 1

The data you're processing is per-line (save for the first value read, which technically is just a counter, but still resides on its own line). That means you need a strategy for processing data line at a time. You also need to facilitate moving a "cursor" (really just an offset) through the line as you extract vertex+weight pairs.

One way to do this is using getline (part of POSIX) for reading the lines dynamically, then using sscanf to extract the values, and in particular using the %n added format specifier to track how many characters were consumed in the last formatted read. This feature will allow you to advance a next-read-from position in the line buffer so as to track where to get the next pair of vertex+weight.

If you don't have access to POSIX getline you could always (a) write your own, or (b) just use a sufficiently sized line buffer to ensure complete capture of your longest line. But not going to lie; having getline makes it a ton easier.

Anyway..

#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
    if (argc < 2)
        return EXIT_FAILURE;

    // open the file
    FILE * fp = fopen(argv[1], "r");
    if (fp == NULL)
    {
        perror(argv[1]);
        return EXIT_FAILURE;
    }

    // read the first counter of vertices
    int n = 0;
    if (fscanf(fp, "%d", &n) == 1 && n > 0)
    {
        // TODO setup your vesticies here using 'n'
        printf("%d verticies will be used\n", n);

        // skip to end of line
        int c;
        while ((c = fgetc(fp)) != EOF && c != '\n');

        // read one line at a time
        char *line = NULL;      // dynamic line pointer
        size_t len = 0;         // length of last line-read

        while (getline(&line, &len, fp) > 0)
        {
            char *cur = line;   // current line position
            int ccs = 0;        // no. of chars read on last scan
            int v1;             // beginning vertex of each line

            // extract the vertex number
            if (sscanf(cur, "%d%n", &v1, &ccs) == 1)
            {
                printf("v1(%d) : ", v1);

                // advance line position past data-just-read
                cur += ccs;

                // read second vertex and weight as pairs
                int v2;
                int w;
                while (sscanf(cur, "%d %d%n", &v2, &w, &ccs) == 2)
                {
                    // TODO: setup the [v1,v2] = w relationship here
                    printf("(%d,%d) ", v2, w);

                    // advance cursor past data just-read
                    cur += ccs;
                }

                fputc('\n', stdout);
            }
        }

        // release whatever buffer we managed
        free(line);
    }

    // close the file before continuing the program
    fclose(fp);

    // TODO: use your data here

    return 0;
}

Run against your input data, the output is:

4 vertices will be used
v1(1) : (2,4) (3,5) (4,5) 
v1(4) : (1,7) (3,3) 
v1(2) : (1,3) (4,10) 

See here for the specific of the scanf family of functions, and note particularly the use of %n in the code above. Its ability to reap how many characters were just processed, and thus how to advance cur to the next read position of the line buffer, is critical to how the above works.