广度优先生成树

Problem Description

设有一连通无向图，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示。利用BFS算法求其广度优先生成树（从下标0的顶点开始遍历），并在遍历过程中输出广度优先生成树的每一条边。

 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0<n<20）；第二行为其n个顶点的值，按输入顺序进行存储；后面有e行，表示e条边的信息，每条边信息占一行，包括边所依附的顶点下标i和j，数据之间用空格隔开。

 Output

输出广度优先生成树的每一条边，每条边信息之后均有一空格，每组输出占一行，具体格式见样例。

 Sample Input

4 4
ABCD
0 1
0 3
1 2
1 3

 Sample Output

(A,B) (A,D) (B,C) 

#include <iostream>
#include <stdlib.h>
#define maxvex 20
#include<stdio.h>
using namespace std;

typedef  struct {
    int adjvex;
} ArcNode1,ArcNode[maxvex][maxvex];
typedef struct {
    ArcNode arc;
    int vertexnum,arcnum;
    char vexs[maxvex];
} Graph;

void CreatUDG(Graph& G,int n,int e) {
    G.vertexnum=n;
    G.arcnum=e;
    for(int i=0; i<G.vertexnum; i++) {
        for(int j=0; j<G.vertexnum; j++) {
            G.arc[i][j].adjvex=0;
        }
    }
    for(int i=0; i<G.vertexnum; i++) {
        cin>>G.vexs[i];
    }
    for(int i=0; i<G.arcnum; i++) {
        int a,b;
        cin>>a>>b;
        G.arc[a][b].adjvex=1;
        G.arc[b][a].adjvex=1;
    }
}


bool visited[maxvex];

void init() {
    for(int i=0; i<maxvex; i++) {
        visited[i]=false;
    }
}

void DFSTraverse(Graph G,int v) {
    visited[v]=true;
    for(int i=0; i<G.vertexnum; i++) {
        if(!visited[i]&&G.arc[v][i].adjvex==1) {
            cout<<"("<<G.vexs[v]<<","<<G.vexs[i]<<")"<<" ";
            DFSTraverse(G,i);
        }
    }
}

void BFSTraverse(Graph G,int v) {
    int rear=-1;
    int front=-1;
    int Q[maxvex];
    Q[++rear]=v;
    visited[v]=true;
    while(rear!=front) {
        int q=Q[++front];
        for(int i=0; i<G.vertexnum; i++) {
            if(visited[i]==false&&G.arc[q][i].adjvex==1) {
                cout<<"("<<G.vexs[q]<<","<<G.vexs[i]<<")"<<" ";
                visited[i]=true;
                Q[++rear]=i;
            }
        }
    }

}

int main() {
  
    int n,e;
    while(cin>>n>>e) {
        Graph G;
        CreatUDG(G,n,e);
        init();
        BFSTraverse(G,0);
        cout<<endl;
    }
    return 0;
}