数据结构与算法-图的最短路径算法

0. 数据结构

#define MAXVEX 20
#define INFINITYC 65535

typedef struct {
    int vexs[MAXVEX];
    int arc[MAXVEX][MAXVEX];
    int numVertexes, numEdges;
} MGraph;

注意:

以下算法提到的v0可以是任意顶点，实现的时候可能需要调整一下代码，这里以v0顶点为索引0生成的邻接矩阵为例。

• Dijkstra算法 只计算v0出发到其他顶点的距离。
• Floyd算法 计算所有顶点出发到其他顶点的距离。

1. Dijkstra算法

1.1 思想

从v0顶点出发，维护一个访问表和总距离表。(路径表根据需求选择)

• 每次遍历，从总距离表中找到最短距离的顶点。
• 从最短距离的顶点出发，比较到达每个顶点的总距离，如果总距离更短则更新总距离表。
  • 如果维护路径表，也在此更新。

1.2 实现

/// Dijkstra算法
/// @param G  图
/// @param pathArcs 前驱顶点下标
/// @param pathLengths 表示从v0到vi的总距离表
void ShortestPath_Dijkstra(MGraph G, int *pathArcs, int *pathLengths) {
    int visited[MAXVEX]; // 是否访问过
    // 1.初始化数据
    for (int i = 0; i < G.numVertexes; i++) {
        visited[i] = 0; // 都没有访问过
        pathArcs[i] = 0; // 前驱节点都是v0
        pathLengths[i] = G.arc[0][i]; // 读入v0的的邻接矩阵
    }
    
    int k = 0; // 从v0开始
    visited[k] = 1; //v0访问过了
    pathLengths[k] = 0; //v0到v0的路径为0
    pathArcs[k] = -1; //v0到v0是没有路径的
    
    // 2.开始主循环，每次求得当前顶点v0到某个顶点的最短路径
    int min, j;
    for (int i = 1; i < G.numVertexes; i++) {
        // 3.寻找离v0最近的顶点
        min = INFINITYC;
        for (j = 0; j < G.numVertexes; j++) {
            if (!visited[j] // 还没有访问过这个顶点
                && pathLengths[j] < min) { // v0到vj总距离更短
                min = pathLengths[j];
                k = j;
            }
        }
        // 下面从总距离最短的k顶点出发寻找合适的顶点
        visited[k] = 1; // 访问过k顶点了
        // 4.从k顶点到各顶点的总距离，如果更小则更新总距离表
        for (j = 0; j < G.numVertexes; j++) {
            if (!visited[j] // 还没有访问过这个顶点
                && (min + G.arc[k][j]) < pathLengths[j]) { // v0到vj总距离更短
                pathLengths[j] = min + G.arc[k][j]; // 更新总距离表
                pathArcs[j] = k; // 从k顶点到j顶点更近，则j顶点的前驱为k顶点
            }
        }
    }
}

2. Floyd算法

2.1 思想

从每个顶点出发，通过中转节点是否可以得到更短的总距离。

2.2 实现

/// Floyd算法
/// @param G 图
/// @param pathArcs pathArcs[i][j]从i出发到j的中转顶点
/// @param pathLengths 表示从vi到vj的总距离表
void ShortestPath_Floyd(MGraph G, int pathArcs[MAXVEX][MAXVEX], int pathLengths[MAXVEX][MAXVEX])
{
    // 1.初始化从i出发到j节点的总距离
    int i, j;
    for (i = 0; i < G.numVertexes; i++) {
        for (j = 0; j < G.numVertexes; j++) {
            pathArcs[i][j] = j; // 从i出发现在直接到j
            pathLengths[i][j] = G.arc[i][j]; // 从i出发到j的距离
        }
    }
    // 2.k表示经过的中转顶点
    int k, oriLen, transLen;
    for (k = 0; k < G.numVertexes; k++) {
        for (i = 0; i < G.numVertexes; i++) {
            for (j = 0; j < G.numVertexes; j++) {
                oriLen = pathLengths[i][j]; // 原来的路径长
                transLen = pathLengths[i][k] + pathLengths[k][j]; // 经过中转顶点i→k→j的总距离
                if (oriLen > transLen) {
                    pathLengths[i][j] = transLen; // 距离更短，更新总距离
                    pathArcs[i][j] = pathArcs[i][k]; // 现在从i→j，需要从i→k进行中转
                }
            }
        }
    }
}