数据结构-图-广度优先遍历

  本文采用邻接表法对连通无向图进行广度优先遍历的两种实现方法

  ①默认从下标为零开始的非递归方式

  ②可自定义起始点的非递归方式

  创建方式：数据结构-图-邻接表法创建无向图-CSDN博客

  并附带 数据结构-图-深度优先遍历-CSDN博客的遍历测试样例

#include <queue>
queue<int> Q;
void BFSALG(ALG G)
{ // 从0开始遍历
    int k, v, w, m = 0;
    Arcnode *p = new Arcnode;
    for (k = 0; k < G.vex; k++) // 初始化
    {
        visit[k] = 0;
    }
    for (k = 0; k < G.vex; k++)
    {
        v = k;
        if (!visit[v])
        {              // v对应结点未被访问
            Q.push(v); // v入队
            while (!Q.empty())
            { // 队不空
                m++;
                w = Q.front();
                Q.pop();
                visit[w] = 1; // 标记
                cout << G.verices[w].data;
                if (m != G.vex)
                {
                    cout << "->";
                }
                p = G.verices[w].firstarc; // 第一个顶点的邻接结点
                while (p != NULL)
                { // 判断这些邻接结点并标记和进队
                    if (!visit[p->adjvex])
                    {
                        Q.push(p->adjvex);
                        visit[p->adjvex] = 1;
                    }
                    p = p->nextarc; // 后移
                }
            }
        }
    }
}
int FirstAdjVex(ALG G, int v)
{ // 开始弧的位置
    if (G.verices[v].firstarc != NULL)
        return G.verices[v].firstarc->adjvex;
    else
        return -1;
}
int NextAdjVex(ALG G, int u, int w)
{ // 寻找邻接结点并return
    Arcnode *p;
    p = G.verices[u].firstarc;
    while (p->adjvex != w)
    {
        p = p->nextarc;
    }
    if (p->nextarc != NULL)
        p = p->nextarc;
    else
        return -1;
    return p->adjvex;
}
void BFS(ALG G, int v)
{ // 可以指定开始的位置
    int cnt = 0;
    for (int i = 0; i < Maxnum; i++)
    {
        visit[i] = 0;
    }
    visit[v] = 1;
    Q.push(v);
    while (!Q.empty())
    {
        cnt++;
        int u;
        u = Q.front();
        Q.pop();
        cout << G.verices[u].data;
        if (cnt != G.vex)
        {
            cout << "->";
        }
        for (int w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w))
        { // 从当前的结点一次遍历他的所以邻接结点
            if (!visit[w])
            { // 标记并进队
                visit[w] = 1;
                Q.push(w);
            }
        }
    }
}