Dijkstra算法简单实现（C++）

图的最短路径问题主要包括三种算法：

（1）Dijkstra (没有负权边的单源最短路径）

（2）Floyed (多源最短路径)

（3）Bellman (含有负权边的单源最短路径）

本文主要讲使用C++实现简单的Dijkstra算法

Dijkstra算法简单实现（C++）

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

 #define MAXVEX 9
 #define INFINITY 65535

 typedef int Patharc[MAXVEX];
 typedef int ShortPathTable[MAXVEX];

 typedef struct {
     int vex[MAXVEX];
     int arc[MAXVEX][MAXVEX];
     int numVertexes;
 } MGraph;

 // 构建图
 void CreateMGraph(MGraph *G){
     int i, j, k;
     // 初始化图
     G->numVertexes = ;
     for(i = ; i < G->numVertexes; ++i){
         G->vex[i] = i;
     }
     for(i = ; i < G->numVertexes; ++i){
         for(j = ; j < G->numVertexes; ++j){
             if(i == j)
                 G->arc[i][j] = ;
             else
                 G->arc[i][j] = G->arc[j][i] = INFINITY;
         }
     }

     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;
     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;

     G->arc[][] = ;
     G->arc[][] = ;

     G->arc[][] = ;

     // 设置对称位置元素值
     for(i = ; i < G->numVertexes; ++i){
         for(j = i; j < G->numVertexes; ++j){
             G->arc[j][i] = G->arc[i][j];
         }
     }
 }

 void ShortPath_Dijkstra(MGraph G, int v0, Patharc P, ShortPathTable D){
     int final[MAXVEX];
     int i;
     for(i = ; i < G.numVertexes; ++i){
         final[i] = ;
         D[i] = G.arc[v0][i];
         P[i] = ;
     }
     D[v0] = ;
     final[v0] = ;
     for(i = ; i < G.numVertexes; ++i){
         int min = INFINITY;
         int j, k, w;

         for(j = ; j < G.numVertexes; ++j){// 查找距离V0最近的顶点
             if(!final[j] && D[j] < min){
                 k = j;
                 min = D[j];
             }
         }
         final[k] = ;
         for(w = ; w < G.numVertexes; ++w){// 更新各个顶点的距离
             if(!final[w] && (min + G.arc[k][w]) < D[w]){
                 D[w] = min + G.arc[k][w];
                 P[w] = k;
             }
         }
     }
 }

 // 打印最短路径
 void PrintShortPath(MGraph G, int v0, Patharc P, ShortPathTable D){
     int i, k;
     stack<int> path;
     cout<<"顶点v"<<v0<<"到其他顶点之间的最短路径如下: "<<endl;
     for(i = ; i < G.numVertexes; ++i){
         if(i == v0) continue;
         cout<<"v"<<v0<<"--"<<"v"<<i<<" weight: "<<D[i]<<"  Shortest path: ";
         path.push(i);
         int k = P[i];
         while(k != ){
             path.push(k);
             k = P[k];
         }
         path.push(v0);
         while(!path.empty()){
             if(path.size() != )
                 cout<<path.top()<<"->";
             else
                 cout<<path.top()<<endl;
             path.pop();
         }
     }
 }

 int main(int argc, char const *argv[]) {
     int v0 = ; // 源点
     MGraph G;
     Patharc P;
     ShortPathTable D;
     CreateMGraph(&G);
     ShortPath_Dijkstra(G, v0, P, D);
     PrintShortPath(G, v0, P, D);
     return ;
 }

运行结果

顶点v0到其他顶点之间的最短路径如下:
v0--v1 weight:   Shortest path: ->
v0--v2 weight:   Shortest path: ->->
v0--v3 weight:   Shortest path: ->->->->
v0--v4 weight:   Shortest path: ->->->
v0--v5 weight:   Shortest path: ->->->->
v0--v6 weight:   Shortest path: ->->->->->
v0--v7 weight:   Shortest path: ->->->->->->
v0--v8 weight:   Shortest path: ->->->->->->->
[Finished in .8s]

参考资料

大话数据结构

Dijkstra's algorithm, Wikipedia