06-图1 列出连通集 (25 分)

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:
输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

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

输出样例:

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

朋友们好啊，好久没更新了，最近数据结构图这部分学的很吃力。。主要是因为浙大上的建图的结构个人感觉好多，又要定义图节点，又要边节点，又想偷懒玩其他的事儿，所以这次我就老老实实的写了一遍邻接矩阵的建图过程。（昨天刚考了转专业考试，希望能顺利吧，还有就是这门课要结课了，但是我还有好多不会，看来只有等到暑假的时候刷题了，话说这月29号还有两门考试，啧啧）

对基础的知识的掌握真的很重要（譬如这题要用的队列），我觉得应该把重要的代码都记下来，不能光知道原理，却不知道怎么写，知道怎么写也是很重要的。

#include <stdio.h>
#include <stdlib.h>
#define max 100
#define infinity -1
#define true 100
#define false 99
typedef struct GNode *PtrToGNode;
struct GNode
{
    int Nv;
    int Ne;
    int G[max][max];
};
typedef PtrToGNode MGraph;

typedef struct ENode *PtrToENode;
struct ENode
{
    int v1, v2;
};
typedef PtrToENode Edge;

MGraph createGraph(int VNum)
{
    MGraph G;
    G = (MGraph)malloc(sizeof(struct GNode));
    G->Nv = VNum;
    G->Ne = 0;
    int v1, v2;
    for (v1 = 0; v1 < G->Nv; v1++)
    {
        for (v2 = 0; v2 < G->Nv; v2++)
        {
            G->G[v1][v2] = infinity;
        }
    }
    return G;
}
void insertEdge(MGraph G, Edge E)
{
    G->G[E->v1][E->v2] = 1;
    G->G[E->v2][E->v1] = 1;
}

MGraph BuildGraph()
{
    MGraph G;
    Edge E;
    int VNum;
    int i;
    scanf("%d", &VNum);
    G = createGraph(VNum);
    scanf("%d", &G->Ne);
    for (i = 0; i < G->Ne; i++)
    {
        E = (Edge)malloc(sizeof(struct ENode));
        scanf("%d%d", &E->v1, &E->v2);
        insertEdge(G, E);
    }
    return G;
}

int visited_DFS[20], visited_BFS[20];

void Print(int V)
{
    printf(" %d", V);
}
void DFS(MGraph G, int V)
{
    visited_DFS[V] = true;
    Print(V);
    for (int i = 0; i < G->Nv; i++)
    {
        if (G->G[V][i] != infinity && visited_DFS[i] == false) //有边，且没被访问过
        {
            DFS(G, i);
        }
    }
}
void List_DFS(MGraph G)
{
    int i;
    for (i = 0; i < G->Nv; i++)
    {
        if (visited_DFS[i] == false)
        {
            printf("{");
            DFS(G, i);
            printf(" }\n");
        }
    }
}

typedef struct Node *PtrToNode;
struct Node
{
    int data;
    PtrToNode next;
};
struct QNode
{
    PtrToNode F, R;
};
typedef struct QNode *Queue;

Queue createQ()
{
    Queue Q;
    Q = (Queue)malloc(sizeof(struct QNode));
    Q->F = Q->R = NULL;
    return Q;
}
void enq(Queue Q, int n)
{
    PtrToNode Node;
    Node = (PtrToNode)malloc(sizeof(struct Node));
    Node->data = n;
    Node->next = NULL;
    if (Q->F == NULL)
    {
        Q->F = Q->R = Node;
    }
    else
    {
        Q->R->next = Node;
        Q->R = Node;
    }
}
int DeQ(Queue Q)
{
    int t;
    PtrToNode TNode;
    TNode = Q->F;
    Q->F = Q->F->next;
    t = TNode->data;
    free(TNode);
    return t;
}
int Isempty(Queue Q)
{
    return Q->F != NULL ? 0 : 1;
}
void BFS(MGraph G, int n)
{
    Queue Q;
    Q = createQ();
    enq(Q, n);
    while (!Isempty(Q))
    {
        int V = DeQ(Q);
        Print(V);
        for (int i = 0; i < G->Nv; i++)
        {
            if (G->G[V][i] != infinity && visited_BFS[i] == false)
            {
                visited_BFS[i] = true;
                enq(Q, i);
            }
        }
    }
}
void List_BFS(MGraph G)
{
    int i;
    for (i = 0; i < G->Nv; i++)
    {
        if (visited_BFS[i] == false)
        {
            visited_BFS[i] = true;//标记访问
            printf("{");
            BFS(G, i);
            printf(" }\n");
        }
    }
}
int main()
{
    MGraph G;
    int i;
    G = BuildGraph();
    for (i = 0; i < G->Nv; i++)
    {
        visited_DFS[i] = false;
        visited_BFS[i] = false;//标记数组一定要自己初始化
    }
    List_DFS(G);
    List_BFS(G);
    return 0;
}