運用Dijkstra算法求得單源最短路徑C/C++

額…，最近博客有一段時間沒有更新了，本來打算每週兩篇的打算被打斷了，不斷的意識到堅持一件事長久的做下去是多麼的不易，當然也不是說上週什麼事情都沒有做，只是計算機圖形學的作業確實是花了一段時間，雖然最終的效果可能沒有那麼理想，但確實是自己想要做好的一件事，所以覺得花的時間也是值得的，學一些新的技術固然不錯，但個人覺得計算機系的必須要有着堅實的基礎，所以數據結構與算法一定是我堅持的方向，好了，先展示下我作業的效果再開始正題吧…

一、 算法描述
Dijistra主要用於求得單源最短路徑，對帶權有向圖G = (V，E)，源點v0屬於V，設置兩個頂點集合S和T = V – S，集合S中存放已找到最短路徑的頂點，集合T存放當前還未找到最短路徑的頂點。初始狀態時，集合S中只包含源點v0，然後不斷從集合T中選取到頂點v0路徑長度最短的頂點u加入集合S中，集合S每加入一個新的頂點u，都要修改頂點v0到集合T中剩餘頂點的最短路徑長度值，集合T中各頂點新的最短路徑長度值爲原來的最短路徑長度值與頂點u的最短路徑長度值加上u到改頂點的路徑長度中的較小值。此過程不斷重複，直到集合T的頂點全部加入到S中爲止。

二、 算法過程

三、算法實現

/*
 *Dijkstra算法求得單源最短路徑，運用鄰接矩陣進行圖的儲存
 */
#include<stdio.h>
#include<malloc.h>
#define MaxVertexNum 100
#define MAX 9999
typedef char VertexType ;
typedef int EdgeType ;
/*
 *定義圖的存儲結構
 */
typedef struct
{
    VertexType  vexs[MaxVertexNum][3] ; //定義頂點表
    EdgeType    edges[MaxVertexNum][MaxVertexNum] ; //定義邊表
    int n , e ; //定義頂點數與邊數
} MGraph ;
/*
 *創建棧，保存路徑
 */
typedef struct
{
    VertexType way[MaxVertexNum][3] ;
    int top ;
} Stack ;
/*
 *構建圖鄰接矩陣
 */
void CreateMGraph(MGraph *G)
{
    int i , j , k , w ;
     printf("請輸入定點數與邊數（輸入格式爲：頂點數,邊數）：") ;
     scanf("%d,%d" , &G->n , &G->e) ;
     printf("請輸入頂點信息（輸入格式爲：頂點號<CR>）：\n") ;
     for(i = 0 ; i < G->n ; i++)
     {
         scanf("%s" , G->vexs[i]) ;
     }
     //初始化鄰接矩陣
     for(i = 0 ; i < G->n ; i++)
     {
         for(j = 0 ; j < G->n ; j++)
         {
             G->edges[i][j] = MAX ;
         }
     }
     printf("請輸入每條邊對應的兩個頂點序號以及權值（輸入格式爲：i,j,w）：\n") ;
     for(k = 0 ; k < G->e ; k++)
     {
         scanf("%d,%d,%d" , &i , &j , &w) ;
         G->edges[i][j] = w ;
     }
     for(i = 0 ; i < G->n ; i++)
     {
         for(j = 0 ; j < G->n ; j++)
         {
             printf("%04d " , G->edges[i][j]) ;
         }
         printf("\n") ;
     }
}
int finall[MaxVertexNum] ; //定義全局變量，記錄頂點是否已求出最短路徑
/*
 *求得單源最短路徑算法，即Dijkstra算法
 *G爲鄰接矩陣 ， v0爲源點 ， P爲v0到各頂點v的路徑 ， D爲最短路徑長度
 */
void ShortestPath_1(MGraph G , int v0 , Stack *sw , int *D)
{
    int v , w , i ,  j , min  , k ;
    for(w = 0 ; w < G.n ; w++)
    {
        sw[w].top = -1 ; //將路徑置空
    }
    for(v = 0 ; v < G.n ; v++)
    {
        finall[v] = 0 ;
        D[v] = G.edges[v0][v] ;
        if(D[v]<MAX)
        {
            //對該點當前最短路徑進行初始化
           sw[v].top++;
           for(k = 0 ; k < 3 ; k++)
           {
               sw[v].way[sw[v].top][k] = G.vexs[v0][k];
           }
           sw[v].top++;
           for(k = 0 ; k < 3 ; k++)
           {
               sw[v].way[sw[v].top][k] = G.vexs[v][k];
           }
        }
    }
    D[v0] = 0 ;
    finall[v0] = 1 ;
    for(i = 1 ; i < G.n ; i++)
    {
       min = MAX ;
       //在每次循環中找到當前路徑最短的點
       for(w = 0 ; w < G.n ; w++)
       {
           if(!finall[w])
           {
               if(D[w] < min)
               {
                   v = w ;
                   min = D[w] ;
               }
           }
       }
       finall[v] = 1 ;
       for(w = 0 ; w < G.n ; w++)
       {
           if(!finall[w]&&((min + G.edges[v][w]) < D[w]))
           {
                // 修改路徑與路徑長度
                sw[w].top = sw[v].top ;
                for(j = 0 ; j <= sw[v].top ; j++)
                {
                    for(k = 0 ; k < 3 ; k++)
                    {
                        sw[w].way[j][k] = sw[v].way[j][k] ;
                    }
                }
                sw[w].top++ ;
                for(k = 0 ; k < 3 ; k++)
                {
                    sw[w].way[j][k] = G.vexs[w][k];
                }
               D[w] = min + G.edges[v][w] ;
           }
       }
    }
}
/*
 *測試代碼
 */
void main()
{
    MGraph *G ;
    Stack w[MaxVertexNum] ;
    int i , j ;
    int P[MaxVertexNum][MaxVertexNum] , D[MaxVertexNum] ;
    G = (MGraph*)malloc(sizeof(MGraph)) ;
    CreateMGraph(G) ;
    ShortestPath_1(*G , 0 , w , D) ;
    //對最短路徑與最短路徑長度進行輸出
    for(i = 0 ; i < G->n ; i++)
    {
        if(D[i] < MAX)
        {
            for(j = 0 ; j <= w[i].top ; j++)
            {
                printf("%s->" , w[i].way[j]) ;
            }
            printf("---%d \n" , D[i]) ;
        }
    }
}