PTA数据结构与算法题目集(中文) 7-6

PTA数据结构与算法题目集(中文)  7-6

7-6 列出连通集 (25 分)

 

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

输入格式:

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

输出格式:

按照"{ v​1​​ v​2​​ ... v​k​​ }"的格式，每行输出一个连通集。先输出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 }

题目分析:考察图基本功能的实现 深度优先遍历和广度优先遍历的实现 注意因为有的点不连通 所以要遍历一边 所有图节点看是否还有未被收录的
深度优先遍历使用递归访问 广度优先遍历利用队列来进行访问

#define _CRT_SECURE_NO_WARNINGS   
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define MaxVertexNum 100

typedef struct ENode* Edge;
struct ENode
{
    int V1, V2;
};
typedef struct GNode* Graph;
struct GNode
{
    int Nv;
    int Ne;
    int G[MaxVertexNum][MaxVertexNum];
};

Graph BuildGraph(int VertexNum)
{
    Graph Gra;
    Gra = (Graph)malloc(sizeof(struct GNode));
    Gra->Ne = 0;
    Gra->Nv = VertexNum;
    for (int i = 0; i < VertexNum; i++)
        for (int j = 0; j < VertexNum; j++)
            Gra->G[i][j] = 0;
    return Gra;
}
void InsertEdge(Edge E, Graph Gra)
{
    Gra->G[E->V1][E->V2] = 1;
    Gra->G[E->V2][E->V1] = 1;
}
Graph CreatGraph()
{
    Edge E;
    int N, M;
    scanf("%d%d", &N, &M);
    Graph G = BuildGraph(N);
    G->Ne = M;
    for (int i = 0; i < M; i++)
    {
        E = (Edge)malloc(sizeof(struct ENode));
        int V1, V2;
        scanf("%d%d", &V1, &V2);
        E->V1 = V1;
        E->V2 = V2;
        InsertEdge(E, G);
    }
    return G;
}
int IsEdge(Graph G, int V1, int V2)
{
    return G->G[V1][V2] == 1;
}
int Collected[MaxVertexNum];
void Initialize()
{
    for (int i = 0; i < MaxVertexNum; i++)
        Collected[i] = 0;
}
void DFS(Graph G,int i)
{
    printf("%d ", i);
    Collected[i] = 1;
    for (int j = 0; j < G->Nv; j++)
    {
        if (!Collected[j]&&IsEdge(G,i,j))
            DFS(G, j);
    }
}

int Queue[10];
int Front = 1;
int Rear = 0;
int Size = 0;
int Succ(int num)
{
    if (num == 10)
        return 0;
    else
        return num;
}
void EnQueue(int num)
{
    Rear = Succ(Rear + 1);
    Queue[Rear] = num;
    Size++;
}
int DeQueue()
{
    int Value = Queue[Front];
    Front = Succ(Front + 1);
    Size--;
    return Value;
}
int IsEmpty()
{
    return Size == 0;
}
void BFS(Graph G,int i)
{
    EnQueue(i);
    Collected[i] = 1;
    while (!IsEmpty())
    {
        int Tmp = DeQueue();
        printf("%d ", Tmp);
        for (int j = 0; j < G->Nv; j++)
        {
            if (!Collected[j] && IsEdge(G, Tmp, j))
            {
                EnQueue(j);
                Collected[j] = 1;
            }
        }
    }
}
int main()
{
    Graph G=CreatGraph();
    for (int i = 0; i < G->Nv; i++)
    {
        if (!Collected[i])
        {
            printf("{ ");
            DFS(G, i);    
            printf("}");
            printf("
");
        }
    }
    Initialize();
    for (int i = 0; i < G->Nv; i++)
    {
        if (!Collected[i])
        {
            printf("{ ");
            BFS(G, i);
            printf("}");
            printf("
");
        }
    }
    return 0;
}