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

题目输入：
第一行：给出N个顶点，E条边
以下E行给出每条边的两个端点
题目输出：
分别输出DFS、BFS的结果

代码如下：

#include<stdio.h>
#include<stdlib.h>
#define MaxVertexNum 10
#define true 1
#define false 0
typedef int Bool;
typedef int Vertex;
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;
    int Ne;
    int G[MaxVertexNum][MaxVertexNum];
};
typedef PtrToGNode MGraph;
typedef struct QNode{
    Vertex *Data;
    int front;
    int rear;
}Queue;
Queue *CreateQueue(int);
void Enqueue(Queue *,Vertex);
int Dequeue(Queue *);
Bool TAG=false;
Bool Visited[MaxVertexNum];
MGraph CreateGraph(int,int);
void DFS(MGraph,Vertex);
void BFS(MGraph,Vertex,Queue *);
void ResetVisit(MGraph,Bool *);
int main()
{
    int N,E;
    scanf("%d %d",&N,&E);
    MGraph G=CreateGraph(N,E);
    int i;
    for(i=0;i<N;i++)
    {
        if(Visited[i]==false)
        {
            DFS(G,i);
            printf("}");
            printf("\n");
            TAG=false;
        }
    }
    ResetVisit(G,Visited);
    Queue *PtrQ=CreateQueue(MaxVertexNum);
    for(i=0;i<N;i++)
    {
        if(Visited[i]==false)
        {
            BFS(G,i,PtrQ);
            printf("}");
            printf("\n");
            TAG=false;
        }
    }
    return 0;
}
void ResetVisit(MGraph Graph,Bool *Visit)
{
    TAG=false;
    Vertex V,W;
    for(V=0;V<Graph->Nv;V++)
    {
        Visit[V]=false;
    }
}
MGraph CreateGraph(int N,int E)
{
    MGraph Graph;
    Graph=(MGraph)malloc(sizeof(struct GNode));
    Graph->Nv=N;
    Graph->Ne=E;
    int i;
    int n,e;
    Vertex V,W;
    for(V=0;V<N;V++)
    {
        for(W=0;W<N;W++)
        {
            Graph->G[V][W]=0;
        }
        Visited[V]=false;
    }
    for(i=0;i<E;i++)
    {
        scanf("%d %d",&n,&e);
        Graph->G[n][e]=1;
        Graph->G[e][n]=1;
    }
    return Graph;
}
void DFS(MGraph Graph,Vertex V)
{
    if(TAG==false)
    {
        TAG=true;
        printf("{ ");
    }
    printf("%d ",V);
    int i;
    Visited[V]=true;
    for(i=0;i<Graph->Nv;i++)
    {
        if(Graph->G[V][i]!=0&&Visited[i]==false)
        {
            DFS(Graph,i);
        }
    }
}
Queue *CreateQueue(int M)
{
    Queue *PtrQ=(Queue *)malloc(sizeof(Queue));
    PtrQ->Data=(Vertex *)malloc(M*sizeof(Vertex));
    PtrQ->front=PtrQ->rear=-1;

    return PtrQ;
}
Bool IsFull(Queue *PtrQ)
{
    Bool full=false;
    if((PtrQ->rear+1)%MaxVertexNum==PtrQ->front)
    {
        full=true;
    }
    return full;
}
Bool IsEmpty(Queue *PtrQ)
{
    Bool empty=false;
    if(PtrQ->front==PtrQ->rear)
    {
        empty=true;
    }
    return empty;
}
void Enqueue(Queue *PtrQ,Vertex V) 
{
    if(!IsFull(PtrQ))
    {
        PtrQ->rear=(PtrQ->rear+1)%MaxVertexNum;
        PtrQ->Data[PtrQ->rear]=V;
    }
}
int Dequeue(Queue *PtrQ)
{
    if(!IsEmpty(PtrQ))
    {
        PtrQ->front=(PtrQ->front+1)%MaxVertexNum;
        return PtrQ->Data[PtrQ->front];
    }
}
void BFS(MGraph Graph,Vertex nv,Queue *PtrQ)
{
    Vertex V,W;
    if(TAG==false)
    {
        TAG=true;
        printf("{ ");
    }
    printf("%d ",nv);
    Visited[nv]=true;
    Enqueue(PtrQ,nv);
    while(!IsEmpty(PtrQ))
    {
        V=Dequeue(PtrQ);
        for(W=0;W<Graph->Nv;W++)
        {
            if(Visited[W]==false&&Graph->G[V][W]!=0)
            {
                printf("%d ",W);
                Visited[W]=true;
                Enqueue(PtrQ,W);
            }
        }
    }
}