dijstra算法

dijstra.h

#ifndef DIJSTRA_H_INCLUDED
#define DIJSTRA_H_INCLUDED
 
#define  MAXVEX   100  /**< 最多顶点数 */
#define  INFINITY    65535/**< 不存在该边是的权值 */
 
struct  graph;
typedef  struct  graph  *Graph;
typedef  int  VertexType;
typedef  int     EdgeType;
typedef  int     PathMatrix[MAXVEX];
typedef  int     ShortPathTable[MAXVEX];
 
 
struct   graph
{
    VertexType   vertex[MAXVEX];
    EdgeType   edge[MAXVEX][MAXVEX];
    int   numvertex,numedge;
};
 
void  CreatGraph(Graph  G);/**< 创建图 */
void  PrintGraph(Graph  G);/**<  将图一临街矩阵的形式打印出来*/
void  Dijstra(Graph  G, int  v0, PathMatrix  P, ShortPathTable  D);
 
#endif // DIJSTRA_H_INCLUDED

dijstra.c

#include  <stdio.h>
#include  <malloc.h>
#include  "dijstra.h"
 
 
void  CreatGraph(Graph  G)
{
    int  i,j,k,w;
 
    printf("input  the  number  of vertex ang  edge:\n");
    printf("the number of  vertex :");
    scanf("%d",&G->numvertex);
    printf("\n");
    printf("the number of edge:");
    scanf("%d",&G->numedge);
 
    /**< 输入顶点 */
    for(i=0;i<G->numvertex;i++)
    {
           printf("输入第%d 顶点：",i+1);
           scanf("%d",&G->vertex[i]);
    }
 
 
    /**< 矩阵初始化 */
    for(i=0;i<G->numvertex;i++)
    {
        for(j=0;j<G->numedge;j++)
        {
            G->edge[i][j] = INFINITY;
        }
    }
 
    /**< 输入边的权值此处一边控制循环次数 */
    for(k=0;k<G->numedge;k++)
    {
        printf("input     vertex  and weight:\n");
        scanf("%d %d %d",&i,&j,&w);
        G->edge[i][j] = w;
        G->edge[j][i] =G->edge[i][j];
 
    }
}
 
void  PrintGraph(Graph  G)
{
    int  i,j;
 
    for(i=0;i<G->numvertex;i++)
    {
        for(j=0;j<G->numvertex;j++)
        {
            if(G->edge[i][j] == INFINITY)
                printf("\t**");
            else
                printf("\t%d",G->edge[i][j]);
        }
        printf("\n");
    }
}
 
/** \brief 最短路径算法
 *图、起点以及两个辅助数组
 * \param pathmatrix表示路径（该点之前的一个点）
 * \param Shortpathtable表示道该点的路径长
 * \return 无返回值
 *作者：曼珠沙华 2013年10月
 */
 
void  Dijstra(Graph  G, int  v0, PathMatrix  P, ShortPathTable  D)
{
    int  v, w, k, min;
    int   final[MAXVEX];     /**< 标志数组如值为1表示已找到该点的最小路径 */
 
    /**< 初始化数组值 */
    for(v=0; v < G->numvertex; v++)
    {
        final[v] =0;             /**< 全部为未找到 */
        D[v] = G->edge[v0][v];   /**< 初始化为第一行的权值，同Prime算法 */
        P[v] = 0;                 /**< 前驱均为0 */
    }
 
    D[v0] = 0;
    final[v0] = 1;           /**< 表示v0已找到 */
 
 
    for(v=1; v < G->numvertex; v++)
    {
        min = INFINITY;
        for(w=0; w < G->numvertex; w++)
        {
            if(!final[w]  && D[w] < min)       /**< 开始比较D[w]的值  如较小则改为当前值 */
            {
                k=w;                                         /**< 较小值得相应点  同prime算法 */
                min=D[w];
            }
        }
 
        final[k] = 1;                        /**< 表示该点最小路径已找到 */
 
        /** \brief 关键循环保证所找路径为最小
         *  在已找到最短路径（v0,vk）的基础上再次比较找到下一个更短的权值
         * \param将k改为下一个点点最小权值的前驱
         * \param
         * \return
         *
         */
 
        for(w=0; w < G->numvertex; w++)
        {
            if(!final[w] && min + G->edge[k][w] < D[w])
            {
                D[w] =min +G->edge[k][w];
                P[w] =k;
            }
        }
    }
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include  "dijstra.c"
 
int main()
{
    int v0,i;
    i=v0=0;
    PathMatrix  P;
    ShortPathTable  D;
    Graph  G;
    G=(Graph)malloc(sizeof(struct  graph));
 
 
    CreatGraph(G);
    PrintGraph(G);
    Dijstra(G, v0, P,D);
 
    printf("\n源点到各顶点的最短路径长度为:\n");
    for(i=1;i<G->numvertex;++i)
        printf("v%d - v%d : %d \n",G->vertex[0],G->vertex[i],D[i]);
 
    return 0;
}