利用邻接表实现无向图的广度优先遍历

利用邻接表实现无向图的广度优先遍历

#include <iostream>
#include <queue>
using namespace std;
#define MVNum 100

typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
}ArcNode;
typedef struct VNode
{
    int data;
    ArcNode *firstarc;
}VNode,AdjList[MVNum];
typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;
}ALGraph;

int i,j,k,v1,v2;

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

int CreateUDN(ALGraph &G)
{   //int i,k,v1,v2,j;
    ArcNode *p1,*p2;
    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=found(G,v1);j=found(G,v2);
        p1=new ArcNode;
        p1->adjvex=j;
        p1->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p1;
        p2=new ArcNode;
        p2->adjvex=i;
        p2->nextarc=G.vertices[j].firstarc;G.vertices[j].firstarc=p2;
    }
    return 0;
}

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

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

int u,v,w;
int visited[MVNum]={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)
{   int i;
    for(i=0;i<G.vexnum;i++)
        visited[i]=0;
    for(i=0;i<G.vexnum;i++)
    {
        if(visited[i]==0)
            BFS(G,i);
    }
}

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