使用队列遍历图BFS [C]

Question

I'm studying graphs at the moment, and I'm using C. When I represent a graph with an adjacency list, I need a queue for a BFS traversal. However, I'm having some issues with the code - I'm not sure if I grasped the concept of a bfs traversal with queues well.

I pasted the commented code below, I hope it's readable. Can someone check it out, or at least provide some info on how to pull this off the right way?

typedef struct {
   char name[21], surname[21];
   double gpa;
} STUDENT;

typedef struct {
   int index;
   struct graph *next;
   STUDENT s;
} GRAPH_NODE;

typedef struct {
   GRAPH_NODE *nodes[50];
   int n;
} GRAPH;

//QUEUE is also a struct, but no need to paste it here

void bfs(GRAPH g, int start) {
     QUEUE queue;
     queue.f = -1;
     queue.r = 0;
     int v;  //will hold the index of the node taken off the queue
             //         (the one that's processed)
     int visited[MAX] = {0};
     visited[start] = 1;

     addToQueue(&queue, start);     //first node is visited, goes to queue

     while (deleteFromQueue(&queue, &v)) {
         printf("%d. ", v+1);
         printStudent(g.nodes[v].s);

         GRAPH_NODE *current = g->nodes[v];
         current->index = v;  //not sure if this is right        

         //this is the part I'm suspicious about
         while (current) {
             int u = current->index;  
             if (!visited[u]) {
                 visited[u] = 1;
                 addToQueue(&queue, u);
             }
             current = current->next;
         }
     } 
 }

Answer 1

I don't see anything blatantly wrong, but the graph structure you show here is too simple to bother with BFS. Every node has at most one outgoing edge: the next pointer. This is just a linked list, which has only one traversal; breadth-first and depth-first are equivalent as there is only at most one node at each depth.

So you really only need that "suspicious" inner loop, it will start from a node and follow the edges to the end of the linked list.