采用邻接矩阵实现有向网的存储，建立有向网，并实现单源最短路径

源代码：

#include <stdio.h>
#include <stdlib.h>
#define MAX 20          //定义的数组长度的最大值
#define Infinite 11111  //宏定义的极大值，相当于无穷，即两个点间不连通

struct Graph                    //代表图的结构体
{
    int ljjz[MAX][MAX];       //存储有向网的邻接矩阵
    int vertextype[MAX];    //点集（本题无用）
    int vexnum;                  //点的数量
    int arcnum;                  //边的数量
};

int min(); 
void Dijtstra();                //求单源最短路径的函数

int main()
{
    struct Graph graph;
    int num,i,j;
    int a,b,c;          
    a = b = c = -1;
    printf("请输入点的个数：");
    scanf("%d",&num);
    graph.vexnum = num;
    graph.arcnum = -1;
    //初始化邻接矩阵
    for(i = 1; i <= num; i++)
    {
        for(j = 1; j < =num; j++)
        {
            if(i != j)
            {
                graph.ljjz[i][j] = Infinite;              // 两个点的距离均初始化为极大值
            }
            else
            {
                graph.ljjz[i][j] = 0;                      // 自己到自己的距离设为0
            }
        }
    }
    //初始化点集
    for(i = 1; i < num; i++)
    {
        graph.vertextype[i] = 1;                  //为了图的定义，本题无意义
    }
    printf("请输入三元组（点的序号 指向的点 权重）\n");     //eg. 第一个点到第二个点的距离为10 则输入：1 2 10（将第一个点设为源点）
    do  
    {
        scanf("%d %d %d",&a,&b,&c);
        graph.ljjz[a][b] = c;
        graph.arcnum++;               // 统计边的数量
    }
    while(a != 0 || b != 0 || c != 0);       //结束输入条件：0 0 0
    Dijtstra(graph);
    return 0;
}
void Dijtstra(struct Graph graph)
{
    int i,j,w;
    int S[MAX],D[MAX];
    S[1] = 1;
    for(i = 2; i < graph.vexnum+1; i++)
    {
        D[i] = graph.ljjz[1][i];
    } //vexnum是点的数量
    for(j = 1; j < graph.vexnum; j++)
    {
        w = min(D,S,graph.vexnum);
        S[w] = 1;
        for(i = 2; i <= graph.vexnum; i++)
        {
            if(S[i] != 1)
            {
                if(D[w] + graph.ljjz[w][i] < D[i])
                {
                    D[i] = D[w] + graph.ljjz[w][i];
                }
            }
        }
    }
    for(i = 2; i <= graph.vexnum; i++)
    {
        printf("到第%d个点最近的距离:%d\n",i,D[i]);
    }
}
int min(int D[],int S[],int n)
{
    int i,min,w;
    min = Infinite;
    w = 2;
    for(i = 2; i <= n; i++)
    {
        if(D[i] <= min && S[i] != 1)
        {
            min = D[i];
            w = i;
        }
    }
    return w;
}

Dijkstra算法基本思想：

1.集合S的初值为S={1}，S代表已找到最短路径的点的集合。

2.D[]为各顶点当前最小路径

3.从当前D[]数组中比较出最小值D[w]（min函数），并将 w加入集合S，并将w进行标记,

  下次D[w]不参与比较，w的最短路径已求出。

4.调整其他各结点的当前最小路径 D[k]=min{D[k],D[w]+C[w][k]}

5.直到S中包含所有顶点