【数据结构与算法实验】建立图并输出最短路径矩阵与最短距离矩阵

实验目的：

在代码实践中，回顾图的表示与最短路径算法知识，提高写代码速度。

预期效果：

第一行输入两个整数m、n（以空格间隔），分别为图的顶点数与边数。然后输入n行，用于输入边，格式为：顶点1 顶点2 权重。输出图的邻接矩阵，然后用求多源最短路径，输出最短路径矩阵与距离矩阵。

实验思路：

前提：所有边权重均为正整数，不存在的边定义为9999，最大顶点数为12。

用邻接矩阵法表示图，用Floyd算法求解多源最短路径。

实验代码：

#include<stdio.h>
#include<stdlib.h>

/* 图实现 */
#define maxVertaxNumber 12
#define NOEDGE 9999

typedef int weightType;
typedef char orderType;
typedef int vertax;

struct GNode {
    int NVertax;
    int NEdge;
    weightType G[maxVertaxNumber][maxVertaxNumber];
    orderType order[maxVertaxNumber];
};
typedef struct GNode *Graph;

struct ENode {
    vertax v1,v2;
    weightType weight;
};
typedef struct ENode *Edge;

Graph createMGraph(int NVertax) {
    Graph ret = (Graph)malloc(sizeof(struct GNode));
    ret->NVertax = NVertax;
    ret->NEdge = 0;
    for (int i=0;i<NVertax;i++) {
        ret->order[i] = i;
        for (int j=0;j<NVertax;j++) {
            ret->G[i][j] = NOEDGE;
        }
    }

    return ret;
}

void insertEgde(Graph graph, Edge edge) {
    graph->G[edge->v1][edge->v2] = edge->weight;
    graph->NEdge++;
}

/* 建图 
    输入格式为：
        Nv Ne
        v1 v2 weight
        v1 v2 weight
        ……
*/
Graph BuildGraph() {
    int Nv,Ne;
    scanf("%d %d",&Nv,&Ne);
    Graph graph = createMGraph(Nv);
    if(Ne!=0) {
        Edge tempEdge = (Edge)malloc(sizeof(tempEdge));
        for (int i=0;i<Ne;i++) {
            scanf("%d %d %d",&(tempEdge->v1),&(tempEdge->v2),&(tempEdge->weight));
            insertEgde(graph,tempEdge);
        }
    }
    return graph;
}
/* 图实现 完 */

/* 主程序 */

// 最短路径数据存储结构
struct dataNode {
    int NVertax;
    weightType D[maxVertaxNumber][maxVertaxNumber];
    vertax path[maxVertaxNumber][maxVertaxNumber];
};
typedef struct dataNode *ptrToData;

// 输出邻接矩阵 函数实现
void showMatrixGraph(Graph graph) {
    puts("图的邻接矩阵如下：");
    for (int i=0; i<graph->NVertax; i++) {
        printf("\t%d",graph->order[i]);
    }
    printf("\n");
    for (int i=0; i<graph->NVertax; i++) {
        printf("%d",i);
        for (int j=0; j<graph->NVertax; j++) {
            printf("\t%d",graph->G[i][j]);
        }
        printf("\n");
    }
}

// Floyd算法实现
ptrToData doFloyd (Graph graph) {
    ptrToData data = (ptrToData)malloc(sizeof(struct dataNode));
    int n = graph->NVertax;
    data->NVertax = n; 
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            data->D[i][j] = graph->G[i][j];
            data->path[i][j] = -1;
        }
    }
    for (int k=0; k<n; k++) {
        for (int i=0; i<n; i++) {
            for (int j=0; j<n; j++) {
                if(data->D[i][k]+data->D[k][j]<data->D[i][j]) {
                    data->D[i][j] = data->D[i][k]+data->D[k][j];
                    data->path[i][j] = k;
                }
            }
        }
    }
    return data;
}

// 输出数据矩阵 函数实现
void showDataMatrix(ptrToData data) {
    int n = data->NVertax;
    puts("最短路径矩阵如下：");
    for (int i=0; i<n; i++) {
        printf("\t%d",i);
    }
    printf("\n");
    for (int i=0; i<n; i++) {
        printf("%d",i);
        for (int j=0; j<n; j++) {
            printf("\t%d",data->path[i][j]);
        }
        printf("\n");
    }
    printf("\n");
    puts("最短距离矩阵如下：");
    for (int i=0; i<n; i++) {
        printf("\t%d",i);
    }
    printf("\n");
    for (int i=0; i<n; i++) {
        printf("%d",i);
        for (int j=0; j<n; j++) {
            printf("\t%d",data->D[i][j]);
        }
        printf("\n");
    }
}

int main() {
    // 建图
    Graph graph = BuildGraph();
    // 输出邻接矩阵
    showMatrixGraph(graph);
    // 进行Floyd算法并存储数据
    ptrToData data = doFloyd(graph);
    // 输出数据
    showDataMatrix(data);
    
    getchar();
    getchar();
    return 0;
}

测试结果：