最短路径：Dijkstra算法

参考书籍：数据结构（C语言版）清华大学出版社

基本概念

Dijkstra算法：Dijkstra提出了一个按路径长度递增的次序产生最短路径的算法。
Dijkstra算法解决的对象：单源点最短路径问题。

算法实现思路

• 图中所有边存储在邻接表中，所有的顶点存储在一个结构体组中，通过其下标对顶点进行操作

结构体声明

1. 边结构体的声明

typedef struct ArcNode{
    int adjvexNum; //该弧所指向的顶点在图的定点结构体组中的下角标
    struct ArcNode *nextarc;
    int weight;
}ArcNode;

• adjvexNum 为这条边的尾顶点的数组下标。
• nextarc 为邻接表的下一条与顶点邻接的边。
• weight 为边的权值。

2. 顶点结构体的声明

typedef struct VexNode{
    ArcNode *firstarc;
    int known;
    int dist;
    int path;
    int data;
}VexNode,AdjList[MAX_VERTEX_NUM];

• firstarc 指向其邻接表
• known 表示该节点的最短路径是否已经明确。
• dist 表示源点到该顶点的最短路径的长度（权值之和）
• path 表示Dijkstra算法中某个顶点的在最短路径中的前序顶点，在算法过程中可能会发生改变。

3. 图结构体声明

typedef struct {
    AdjList vertice;
    int vexnum,arcnum;  // 图当前顶点数和边数
    GraphKind kind; //图的种类类型
}MGraph;

• vertice 用来存储一个图中顶点信息的数组

图的创建

void addEdge(int a,int b,int weight,MGraph &G){
    int vex1,vex2;
    for(int i = 0; i < G.vexnum; i++){ //通过用户输入的数据匹配顶点对应的下标
        if(a == G.vertice[i].data){
            vex1 = i;
        }
        if(b == G.vertice[i].data){
            vex2 = i;
        }
    }
    ArcNode *arcNode = (ArcNode*)malloc(sizeof(ArcNode)); //初始化所有边
    arcNode->nextarc = NULL;
    arcNode->adjvexNum = vex2;
    arcNode->weight = weight;

    if(G.vertice[vex1].firstarc == NULL){    //将边加入到邻接表
        G.vertice[vex1].firstarc = arcNode;
    }
    else{
        ArcNode *t = NULL;
        ArcNode *pre = NULL;
        for(t = G.vertice[vex1].firstarc;t != NULL;t = t->nextarc){
            pre = t;
        }
        pre->nextarc = arcNode;
    }
}

void CreateGraph(MGraph &G){
    //scanf("%d %d",&G.vexnum,&G.arcnum);
    G.vexnum = 7;
    G.arcnum = 12;
    for(int i = 0; i < G.vexnum; i++) {  //初始化所有顶点
        G.vertice[i].firstarc = NULL;
        G.vertice[i].known = 0;
        G.vertice[i].dist = INT_MAX;
        G.vertice[i].path = -1;
    }
    G.vertice[0].data = 1;
    G.vertice[1].data = 2;
    G.vertice[2].data = 3;
    G.vertice[3].data = 4;
    G.vertice[4].data = 5;
    G.vertice[5].data = 6;
    G.vertice[6].data = 7;
//for(int k = 0; k < G.arcnum; k++){
// int vex1,vex2,weight;  //输入一条边的起点和终点以及这条边的权值
//  scanf("%d %d",&vex1,&vex2);
//}
    int a[12]={
            1,1,2,2,3,3,4,4,4,4,5,7
    };
    int b[12]={
            2,4,4,5,1,6,3,5,6,7,7,6
    };
    int weight[12]={
            2,1,3,10,4,5,2,2,8,4,6,1
    };
    for(int i = 0; i < G.arcnum; i++)
    addEdge(a[i],b[i],weight[i],G);
}

• 初始化所有顶点的known值为0
• 初始化所有顶点的dist值为INT_MAX，为了满足Dijkstra算法寻找最短路径的操作，所以初值要设定为最大值。
• 所有顶点的前序节点path都默认为 -1，方便在所有节点都得到前置节点时通过-1找到初始节点并停止寻找path。

Dijkstra 算法

void Dijkstra(MGraph G)
{
    G.vertice[0].known = 1; // 初始化源节点
    G.vertice[0].dist = 0;
    for (ArcNode *t = G.vertice[0].firstarc; t; t = t->nextarc) {
        G.vertice[t->adjvexNum].dist = t->weight;
        G.vertice[t->adjvexNum].path = 0;
    }
    int k; // 权值最小路径尾顶点下标
    for(int i = 1; i < G.vexnum; i++){
        int min = INT_MAX;
        for (int j = 0; j < G.vexnum; j++)
        {
            if (G.vertice[j].known == 0 && G.vertice[j].dist < min)
            {
                min = G.vertice[j].dist;
                k = j;
            }
        }
        G.vertice[k].known = 1;  // 标记"顶点k"为已经获取到最短路径
        for (ArcNode *t = G.vertice[k].firstarc; t; t = t->nextarc) {
            if (!G.vertice[t->adjvexNum].known) {
                if(G.vertice[k].dist + t->weight < G.vertice[t->adjvexNum].dist) {
                    G.vertice[t->adjvexNum].dist = G.vertice[k].dist + t->weight;
                    G.vertice[t->adjvexNum].path = k;
                }
            }
        }
    }
    int target = 6;  // 用户输入的终点
    int dataset[100];  // 用于整理path数据正向输出路径
    int dataNum = 0;
    for(int i = 0; i < G.vexnum; i++){
        if(G.vertice[i].data == target){
            for(int k = i; k != -1; k = G.vertice[k].path){ // 正序输出最小路径
                dataset[dataNum] = G.vertice[k].data;
                dataNum++;
            }
            for(int l = dataNum-1;l > 0; l--){
                printf("%d,",dataset[l]);
            }
            printf("%d",dataset[0]);
        }
    }
}

1. 源点数据初始化

G.vertice[0].known = 1; // 初始化源节点
G.vertice[0].dist = 0;

2. 为源点邻接的顶点设置dist值和path值

for (ArcNode *t = G.vertice[0].firstarc; t; t = t->nextarc) {
        G.vertice[t->adjvexNum].dist = t->weight;
        G.vertice[t->adjvexNum].path = 0;
    }

3. 开始循环判断所有除源点以外其他顶点的dist值和path值

• 循环进行下述两步操作

int min = INT_MAX;
        for (int j = 0; j < G.vexnum; j++)
        {
            if (G.vertice[j].known == 0 && G.vertice[j].dist < min)
            {
                min = G.vertice[j].dist;
                k = j;
            }
        }

• 找到与该顶点 j 相邻最近的点 k（对应的边权值最小）

G.vertice[k].known = 1;  // 标记"顶点k"为已经获取到最短路径
        for (ArcNode *t = G.vertice[k].firstarc; t; t = t->nextarc) {
            if (!G.vertice[t->adjvexNum].known) {
                if(G.vertice[k].dist + t->weight < G.vertice[t->adjvexNum].dist) {
                    G.vertice[t->adjvexNum].dist = G.vertice[k].dist + t->weight;
                    G.vertice[t->adjvexNum].path = k;
                }
            }
        }

• 与所有与点k相邻的点比较其dist值
• k点的dist值与k点到邻点边的权值之和与其相邻的点的dist值比较，若前者小，则更新路径值dist和前序顶点path。

原理

• 若该节点没有被赋值，则dist值为正无穷，判断结果一定失败。
• 若该节点有过值通过k点的最短路径长度和与其相邻的权值足以与之前的dist值对应的情况进行比较哪个是更短的路径，对每个顶点入度的情况都遍历检查了一遍，达到效率较优的情况下检查全图得到源点到目标顶点最短路径的目的。