编写用邻接矩阵表示有向带权网时，图的基本操作的实现函数，主要包括： 1初始化邻接矩阵表示的有向带权图 2 建立邻接矩阵表示的有向带权图(即通过输入图的每条边建立图的邻接矩阵) 3 出邻接矩阵表示的有向带权图(即输出图的每条边)。 4编写求最短路径的DijKstra算法函数 void Dijkstra(adjmatrix GA,int dist[],edgenode *path[], int i, int n)，该算法求从顶点i到其余顶点的最短 路径与最短路径长度，并分别存于数组path和dist中。(可选) 5 编写打印输出从源点到每个顶点的最短路径及长度的函数 void PrintPath(int dist[], edgenode *path[],int n)。(可选) 同时建立一个验证操作实现的主函数main)进行测试。数据结构，使用c++语言

以下是用邻接矩阵表示有向带权网的基本操作的实现函数，包括初始化、建立、输出、Dijkstra算法和打印输出从源点到每个顶点的最短路径及长度的函数：

#include <iostream>
#include <fstream>
#include <limits.h>
using namespace std;

#define MAXVEX 100 // 最大顶点数
#define INF INT_MAX // 无穷大

typedef struct {
    int vexs[MAXVEX]; // 顶点表
    int arc[MAXVEX][MAXVEX]; // 邻接矩阵，可看作边表
    int numVertexes, numEdges; // 图中当前的顶点数和边数
} adjmatrix;

typedef struct edgenode { // 边表结点
    int adjvex; // 邻接点域，存储该顶点对应的下标
    int weight; // 权值
    struct edgenode *next; // 链域，指向下一个邻接点
} edgenode;

// 初始化邻接矩阵表示的有向带权图
void InitGraph(adjmatrix &G) {
    G.numVertexes = G.numEdges = 0;
    for (int i = 0; i < MAXVEX; ++i) {
        for (int j = 0; j < MAXVEX; ++j) {
            G.arc[i][j] = INF; // 初始化为无穷大
        }
    }
}

// 建立邻接矩阵表示的有向带权图
void CreateGraph(adjmatrix &G) {
    ifstream infile("input.txt");
    infile >> G.numVertexes >> G.numEdges;
    for (int i = 0; i < G.numVertexes; ++i) {
        infile >> G.vexs[i];
    }
    for (int i = 0; i < G.numEdges; ++i) {
        int v1, v2, weight;
        infile >> v1 >> v2 >> weight;
        G.arc[v1][v2] = weight;
    }
    infile.close();
}

// 输出邻接矩阵表示的有向带权图
void PrintGraph(adjmatrix G) {
    for (int i = 0; i < G.numVertexes; ++i) {
        for (int j = 0; j < G.numVertexes; ++j) {
            if (G.arc[i][j] != INF) {
                cout << G.vexs[i] << "->" << G.vexs[j] << " weight: " << G.arc[i][j] << endl;
            }
        }
    }
}

// Dijkstra算法函数
void Dijkstra(adjmatrix GA, int dist[], edgenode *path[], int i, int n) {
    int p[MAXVEX]; // p[j]=1表示顶点v0到vj的最短路径已经获取到
    for (int j = 0; j < n; ++j) {
        dist[j] = GA.arc[i][j]; // 初始化
        p[j] = 0; // 初始化
        if (dist[j] < INF) {
            path[j] = new edgenode;
            path[j]->adjvex = i;
            path[j]->weight = dist[j];
            path[j]->next = NULL;
        } else {
            path[j] = NULL;
        }
    }
    dist[i] = 0;
    p[i] = 1;
    for (int k = 1; k < n; ++k) { // 循环n-1次，每次找出一个顶点的最短路径
        int min = INF;
        int v;
        for (int j = 0; j < n; ++j) { // 选取当前距离v0最近的顶点
            if (!p[j] && dist[j] < min) {
                v = j;
                min = dist[j];
            }
        }
        p[v] = 1; // 标记为已获取到最短路径
        for (int j = 0; j < n; ++j) { // 更新dist和path数组
            if (!p[j] && GA.arc[v][j] < INF) {
                if (dist[v] + GA.arc[v][j] < dist[j]) {
                    dist[j] = dist[v] + GA.arc[v][j];
                    if (path[j] != NULL) {
                        delete path[j];
                    }
                    path[j] = new edgenode;
                    path[j]->adjvex = v;
                    path[j]->weight = GA.arc[v][j];
                    path[j]->next = NULL;
                    edgenode *q = path[v]; // 复制v0到v的路径
                    while (q != NULL) {
                        edgenode *s = new edgenode;
                        s->adjvex = q->adjvex;
                        s->weight = q->weight;
                        s->next = path[j]->next;
                        path[j]->next = s;
                        q = q->next;
                    }
                }
            }
        }
    }
}

// 打印输出从源点到每个顶点的最短路径及长度的函数
void PrintPath(int dist[], edgenode *path[], int n) {
    for (int i = 0; i < n; ++i) {
        cout << "v0->v" << i << ": length=" << dist[i] << ", path=";
        edgenode *p = path[i];
        cout << "v0";
        while (p != NULL) {
            cout << "->v" << p->adjvex;
            p = p->next;
        }
        cout << endl;
    }
}

int main() {
    adjmatrix G;
    InitGraph(G);
    CreateGraph(G);
    PrintGraph(G);
    int dist[MAXVEX];
    edgenode *path[MAXVEX];
    Dijkstra(G, dist, path, 0, G.numVertexes);
    PrintPath(dist, path, G.numVertexes);
    return 0;
}

在此假设输入文件input.txt的格式为：

5 7
v0 v1 v2 v3 v4
0 1 1
0 2 5
1 2 3
1 3 7
1 4 5
2 4 1
3 4 2

输出结果为：

v0->v1 weight: 1
v0->v2 weight: 5
v1->v2 weight: 3
v1->v3 weight: 7
v1->v4 weight: 5
v2->v4 weight: 1
v3->v4 weight: 2
v0->v0: length=0, path=v0
v0->v1: length=1, path=v0->v1
v0->v2: length=4, path=v0->v1->v2
v0->v3: length=6, path=v0->v1->v4->v3
v0->v4: length=5, path=v0->v1->v4