利用邻接表构建无向图实现多源spfa算法

前几天接了个任务，内容大概是在一张无向图中实现多源spfa算法。额，网上关于邻接表构图有很多现成的代码，spfa算法的教学更是数不胜数，但是笔者发现有关多起点的无向图构建与spfa算法结合的文章很少（很难找到现成的代码）。于是啊，笔者写了一套无向图多源spfa代码以供大家参考学习。

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

#define MVNum 100                            //最大顶点数

int dis[1000],point[MVNum];                  //dis数组储存距离，而point数组记录点是否在队列中
typedef char PointType;                        //顶点的数据类型
typedef int OtherInfo;                        //和边相关的信息

//图的邻接表存储表示
typedef struct ArcNode {                        //边结点
    int adjvex;                                  //该边所指向的顶点的
    struct ArcNode* nextarc;                      //指向下一条边的指针
    OtherInfo value;                              //和边的权值
}ArcNode;

typedef struct VNode {
    PointType name;                                //顶点名字
    ArcNode* firstarc;                            //指向第一条依附该顶点的边的指针
}VNode, AdjList[MVNum];                           //AdjList表示邻接表类型

typedef struct {
    AdjList vertices;                             //邻接表
    int total_point, total_arc;                 //图的当前顶点数和边数
}ALGraph;


int LocateVex(ALGraph G, PointType v) {
    //确定点v在图中的位置，将数据类型转化
    for (int i = 0; i < G.total_point; ++i)
        if (G.vertices[i].name == v)
            return i;
    return -1;
}//LocateVex

int CreateUDG(ALGraph& G) {
    //采用邻接表表示法，创建无向图G
    int i, k;

    cout << "输入点的名称，如 A " << endl;
    for (i = 0; i < G.total_point; ++i) {              //输入各点，构造表头结点表
        cout << "请输入第" << (i + 1) << "个点的名称:";
        cin >> G.vertices[i].name;               //输入顶点值
        G.vertices[i].firstarc = NULL;            //初始化表头结点的指针域为NULL
    }//for
    cout << endl;

    cout << "请输入一条边依附的顶点,如 a b" << endl;
    for (k = 0; k < G.total_arc; ++k) {                //输入各边，构造邻接表
        PointType v1, v2;
        int i, j;
        cout << "请输入第" << (k + 1) << "条边依附的顶点:";
        cin >> v1 >> v2;                         //输入一条边依附的两个顶点
        i = LocateVex(G, v1);  j = LocateVex(G, v2);
        //确定v1和v2在G中位置，即顶点在G.vertices中的序号

        ArcNode* p1 = new ArcNode;                   //生成一个新的边结点*p1
        cout << "请输入第" << (k + 1) << "条边的权值:";
        cin >> p1->value;
        p1->adjvex = j;                               //邻接点序号为j
        p1->nextarc = G.vertices[i].firstarc;  G.vertices[i].firstarc = p1;
        //将新结点*p1插入顶点vi的边表头部

        ArcNode* p2 = new ArcNode;                //生成另一个对称的新的边结点*p2
        p2->adjvex = i;                             //邻接点序号为i
        p2->value = p1->value;
        p2->nextarc = G.vertices[j].firstarc;  G.vertices[j].firstarc = p2;
        //将新结点*p2插入顶点vj的边表头部
    }
    return 1;
}//CreateUDG

void spfa(ALGraph G)
{
    queue<int> q;
    int j;
    char from_temp, to_temp;
    for (int i = 0; i <= G.total_point; i++)
    {
        dis[i] = 123456789;
        point[i] = 0;                            //0就是不在队列中
    }                                            //初始化
    cout << "输入起点和终点(如:A B)，中间以空格隔开";
    cin >> from_temp >> to_temp;
    int from = LocateVex(G, from_temp);
    int to = LocateVex(G, to_temp);             //将结点从char转化为int,方便操作
    
    q.push(from); dis[from] = 0; point[from] = 1;//队首入队
    while (!q.empty())
    {
        int u = q.front();                      //取出队首
        q.pop(); point[u] = 0;
        ArcNode* p = G.vertices[u].firstarc;

        while (p)
            {
                 j = p->adjvex;
                if (dis[j] > dis[u] + p->value)
                {
                    dis[j] = dis[u] + p->value;
                    if (point[j] == 0)
                    {
                        point[j] = 1;
                        q.push(j);
                    }
                }
                p = p->nextarc;
            }
    }
    cout << dis[to];

}

int main() {
    cout << "************采用邻接表表示法创建无向图**************" << endl << endl;
    cout << "请输入总顶点数，总边数中间以空格隔开:";
    ALGraph G;
    cin >> G.total_point >> G.total_arc;                //输入总顶点数，总边数
    cout << endl;
    CreateUDG(G);
    int i;
    cout << endl;
    cout << "*****邻接表表示法创建的无向图*****" << endl;

    for (i = 0; i < G.total_point; ++i) {
        VNode temp = G.vertices[i];
        ArcNode* p = temp.firstarc;
        if (p == NULL) {
            cout << G.vertices[i].name;
            cout << endl;
        }
        else {
            cout << temp.name;
            while (p) {
                cout << "-> ";
                cout << G.vertices[p->adjvex].name;
                p = p->nextarc;
            }
        }
        cout << endl;
    }                                                   //打印邻接表
    spfa(G);
    return 0;
}

运行效果如下：