利用邻接表实现无向图的广度优先遍历 先输入两个整数（m,n）（分别表示待创建的图顶点数和边数），之后是m个顶点的信息，再之后是n 条边。 输出格式见示例

#include <iostream>
#include <queue>
using namespace std;

typedef struct ArcNode
{
    int adjvex;
    struct ArcNode* nextarc;
} ArcNode;

typedef struct VNode
{
    int data;
    ArcNode* firstarc;
} VNode, AdjList[100];

typedef struct
{
    AdjList vertices;
    int vexnum, arcnum;
} ALGraph;

int i, j, k, v1, v2;

int LocateVex(ALGraph G, int v)
{
    int i;
    for (i =0; i <G.vexnum&& G.vertices[i].data != v; i++);
    return i;
}

void CreateUDG(ALGraph& G)
{
    cin >> G.vexnum >> G.arcnum;
    for (i = 0; i < G.vexnum; i++)
    {
        cin >> G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    for (k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2;
        i = LocateVex(G, v1);
        j = LocateVex(G, v2);
        ArcNode* p1 = new ArcNode;
        p1->adjvex = j;
        p1->nextarc = G.vertices[i].firstarc;
        G.vertices[i].firstarc = p1;

        ArcNode* p2 = new ArcNode;
        p2->adjvex = i;
        p2->nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc = p2;
    }
}

int FirstAdjVex(ALGraph G, int v)
{
    ArcNode* p;
    v1 = LocateVex(G, G.vertices[v].data);
    p = G.vertices[v1].firstarc;
    if (p)
    {
        return p->adjvex;
    }
    else
        return -1;
}

int NextAdjVex(ALGraph G, int v, int w)
{
    ArcNode* p;
    if (v >= 0 && v < G.vexnum && w>0 && w < G.vexnum)
    {
        p = G.vertices[LocateVex(G,G.vertices[v].data)].firstarc;
        while (p->nextarc)
            if (p->adjvex == w)
                return p->nextarc->adjvex;
            else
                p = p->nextarc;
    }
    return -1;
}


int u, v, w;
int visited[100] = { 0 };
void BFS(ALGraph G, int v)
{
    cout << "v" << G.vertices[v].data << ' ';
    visited[v] = 1;
    queue<int> Q;
    Q.push(v);
    while (!Q.empty())
    {
        u = Q.front();
        Q.pop();
        for (w = FirstAdjVex(G, u); w > 0; w = NextAdjVex(G, u, w))
            if (!visited[w])
            {
                cout << "v" << G.vertices[w].data << ' ';
                visited[w] = 1;
                Q.push(w);
            }
    }
}

void BFSTraverse(ALGraph G)
{
    for (v = 0; v < G.vexnum; v++)
        if (!visited[v])
            BFS(G, v);
}

int main()
{
    ALGraph G;
    CreateUDG(G);
    BFSTraverse(G);
    return 0;
}