[DS_PRATICE]列出连通集（c语言）

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

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

输出格式:
按照"{ v1 v2… vk }"的格式，每行输出一个连通集。先输出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 }

这道题其实非常简单，但是代码量稍微有点大？
基本思路是这样的：

1. 建立一个图
2. DFS和BFS（BFS需要使用队列）

以下是本人的代码:

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

#define MaxVertexNum 10

typedef struct VNode{
    int Nv,Ne;
    int G[MaxVertexNum][MaxVertexNum];
}MGraph;

typedef struct queue{
    int Front;
    int Rear;
    int* a;
    int Capacity;
    int Size;
}Queue;

MGraph* CreateGraph(int VertexNum);
void Insert(MGraph* M,int V1,int V2);
Queue* CreateQueue(int N);
void EnQueue(Queue* Q,int V);
int DeQueue(Queue* Q);
void DFS(MGraph* M,int V);
void BFS(MGraph* M,Queue* Q,int V);

static int DVisited[10];
static int BVisited[10];

int main(void)
{
    int N,E;
    int V1,V2;
    MGraph* M;
    Queue* Q;
    scanf("%d%d",&N,&E);
    /* 创建图 */
    M = CreateGraph(N);
    /* 为了BFS创建队列 */
    Q = CreateQueue(N);
    for(int i = 0;i < E;i++)
    {
        scanf("%d%d",&V1,&V2);
        Insert(M,V1,V2);
    }
    /* 遍历图DFS */
    for(int i = 0;i < M->Nv;i++){
        if(!DVisited[i]){
            printf("{ ");
            DFS(M,i);
            printf("}\n");
        } 
    }
    for(int i = 0;i < M->Nv;i++){
         if(!BVisited[i]){
            printf("{ ");
            BFS(M,Q,i);
            printf("}\n");
        } 
    }
    system("pause");
}

void DFS(MGraph* M,int V)
{
    DVisited[V] = 1;
    printf("%d ",V);
    for(int i = 0;i < M->Nv;i++){
        if(M->G[V][i]&&!DVisited[i]){
            DFS(M,i);
        }
    }
}

void BFS(MGraph* M,Queue* Q,int V)
{
    EnQueue(Q,V);
    BVisited[V] = 1;
    printf("%d ",V);
    while(Q->Size != 0){
        V = DeQueue(Q);
        for(int i = 0;i < M->Nv;i++){
            if(!BVisited[i]&&M->G[V][i]){
                BVisited[i] = 1;
                printf("%d ",i);
                EnQueue(Q,i);
            }
        }
    }
}

Queue* CreateQueue(int N)
{
    Queue* Q;
    Q = (Queue*)malloc(sizeof(Queue));
    Q->Front = 0;
    Q->Rear = 0;
    Q->a = (int*)malloc(sizeof(int)*N);
    Q->Capacity = N;
    Q->Size = 0;
    return Q;
}

void EnQueue(Queue* Q,int V)
{ 
    Q->Size++;
    Q->a[Q->Rear] = V;
    Q->Rear = ++Q->Rear % Q->Capacity;
}

int DeQueue(Queue* Q)
{
    int temp;
    temp = Q->a[Q->Front];
    Q->Front = ++Q->Front % Q->Capacity;
    Q->Size--;
    return temp;
}

MGraph* CreateGraph(int VertexNum)
{
    MGraph* M;
    int V,W;
    M = (MGraph*)malloc(sizeof(MGraph));
    M->Ne = 0;
    M->Nv = VertexNum;
    for(V = 0;V < VertexNum;V++)
        for(W = 0; W < VertexNum;W++)
            M->G[V][W] = 0;
    return M;    
}

void Insert(MGraph* M,int V1,int V2)
{
    M->G[V1][V2] = 1;
    M->G[V2][V1] = 1;
}

这题也没有去参考网上其他人的答案，虽然这题很简单，但我还是有点骄傲的。当然我也有一些不严谨的地方，比如队列的判空判满。