06-图1 List Components

这题主要涉及到了队列，无向图的邻接矩阵表示，图的深度和广度优先搜索。又是糙哥，参考了他的程序（http://www.cnblogs.com/liangchao/p/4288807.html），主要是BFS那块，课件上的不太明白。有一点不太明白，图的初始化那块，利用传指向图的指针而不是通过函数返回值为什么不行？代码及题目如下

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

typedef struct MGraph
{
    int vertice;
    int * edge;
    bool * visited;
}MGraph, * pMGraph;
typedef struct Queue
{
    int * elem;
    int head;
    int tail;
    int size;
}Queue, * pQueue;

pMGraph initGraph(int vn);
void link(pMGraph pG, int v1, int v2);
void DFS(pMGraph pG, int v);

void BFS(pMGraph pG, int v);
pQueue createQueue(int vn);
bool isEmpty(pQueue pQ);
void inQueue(pQueue, int v);
int outQueue(pQueue);

int main()
{
//    freopen("in.txt", "r", stdin); // for test
    int i, N, E;
    scanf("%d%d", &N, &E);
    pMGraph pG;
    pG = initGraph(N);
    
    int v1, v2;
    for(i = 0; i < E; i++)
    {
        scanf("%d%d", &v1, &v2);
        link(pG, v1, v2);
    }
    
    for(i = 0; i < N; i++)
    {
        if(!pG->visited[i])
        {
            printf("{ ");
            DFS(pG, i);
            printf("}
");
        }
    }
    memset(pG->visited, false, pG->vertice * sizeof(bool));
    for(i = 0; i < N; i++)
    {
        if(!pG->visited[i])
        {
            printf("{ ");
            BFS(pG, i);
            printf("}
");
        }
    }
//    fclose(stdin); // for test
    return 0;
}

pMGraph initGraph(int vn)
{
    int len;
    len = vn * (vn - 1) / 2;
    
    pMGraph pG;
    pG = (pMGraph)malloc(sizeof(MGraph));
    pG->vertice = vn;
    pG->edge = (int *)malloc(len * sizeof(int));
    memset(pG->edge, 0, len * sizeof(int));
    pG->visited = (bool *)malloc(vn * sizeof(bool));
    memset(pG->visited, false, vn * sizeof(bool));
    
    return pG;
}

void link(pMGraph pG, int v1, int v2)
{
    int index;
    
    if(v1 > v2)
    {
        v1 += v2;
        v2 = v1 - v2;
        v1 -= v2;
    }
    index = v2 * (v2 - 1) / 2 + v1;
    pG->edge[index] = 1;
}

void DFS(pMGraph pG, int v)
{
    int row, col, index;
    
    pG->visited[v] = true;
    printf("%d ", v);
    for(col = 0; col < v; col++)
    {
        index = v * (v - 1) / 2 + col;
        if(pG->edge[index] && pG->visited[col] == false)
            DFS(pG, col);
    }
    for(row = v + 1; row < pG->vertice; row++)
    {
        index = row * (row - 1) / 2 + v;
        if(pG->edge[index] && pG->visited[row] == false)
            DFS(pG, row);
    }
}

void BFS(pMGraph pG, int v)
{
    pQueue pQ;
    pQ = createQueue(pG->vertice);
    
    int row, col, index;
    pG->visited[v] = true;
    printf("%d ", v);
    inQueue(pQ, v);
    while(!isEmpty(pQ))
    {
        v = outQueue(pQ);
        for(col = 0; col < v; col++)
        {
            index = v * (v - 1) / 2 + col;
            if(pG->edge[index] && pG->visited[col] == false)
            {
                pG->visited[col] = true;
                printf("%d ", col);
                inQueue(pQ, col);
            }
        }
        for(row = v + 1; row < pG->vertice; row++)
        {
            index = row * (row - 1) / 2 + v;
            if(pG->edge[index] && pG->visited[row] == false)
            {
                pG->visited[row] = true;
                printf("%d ", row);
                inQueue(pQ, row);
            }
        }
    }
}

pQueue createQueue(int vn)
{
    pQueue pQ;
    pQ = (pQueue)malloc(sizeof(Queue));
    pQ->size = vn + 1;
    pQ->head = pQ->tail = 0;
    pQ->elem = (int *)malloc(pQ->size * sizeof(int));
    
    return pQ;
}

bool isEmpty(pQueue pQ)
{
    if(pQ->head != pQ->tail)
        return false;
    else
        return true;
}

void inQueue(pQueue pQ, int v)
{
    pQ->tail = (pQ->tail + 1) % pQ->size;
    pQ->elem[pQ->tail] = v;
}

int outQueue(pQueue pQ)
{
    pQ->head = (pQ->head + 1) % pQ->size;
    
    return pQ->elem[pQ->head];
}

For a given undirected graph with N vertices and E edges, please list all the connected components by both DFS and BFS. Assume that all the vertices are numbered from 0 to N-1. While searching, assume that we always start from the vertex with the smallest index, and visit its adjacent vertices in ascending order of their indices.

Input Specification:

Each input file contains one test case. For each case, the first line gives two integers N (0<N<=10) and E, which are the number of vertices and the number of edges, respectively. Then E lines follow, each described an edge by giving the two ends. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in each line a connected component in the format "{ v1 v2 ... vk }". First print the result obtained by DFS, then by BFS.

Sample Input:

8 6
0 7
0 1
2 0
4 1
2 4
3 5

Sample Output:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }