有向图某顶点到其他顶点最短路径的C程序实现代码(Dijkstra算法)

#include
#include
#include


//该结构体用来表示从某个顶点可以到达的其他顶点
struct ENode
{
    int secPoint;//顶点号
    int weight;
    ENode *next;//指向下一个顶点的指针
};


//该结构体表示每一个顶点的信息
struct PNode
{
    char value;//顶点的值
    int inDegree;
    int outDegree;
    ENode *next;//指向顶点可以到达的其他第一个顶点的指针
};


//图的结构体，该图最多有100个顶点
struct Map
{
    PNode point[100];//数组的下标就是这个顶点的顶点号
    int numPoint,numEdge;
};


//建图的函数
struct Map *CreateMap()
{
    struct Map *mp = (struct Map*)malloc(sizeof(struct Map));
    int i,j;
    int firP,secP,weight;
    int numP,numE;
    char infoP;

    memset(mp,0,sizeof(struct Map));

    printf("请输入顶点数和边数,格式为‘顶点数，边数’：\n");
    scanf("%d,%d",&numP,&numE);
    mp->numPoint = numP;
    mp->numEdge = numE;

    printf("请输入各个顶点的信息，没有分隔符的连续输入：\n");
    fflush(stdin);
    for(i=0;inumPoint;i++)
    {
        scanf("%c",&infoP);
        mp->point[i].value = infoP;
    }

    printf("请输入边和权重，格式为‘顶点-顶点，权重’\n");
    fflush(stdin);
    for(j=0;jnumEdge;j++)
    {
        scanf("%d-%d,%d",&firP,&secP,&weight);
        struct ENode *newNode = (struct ENode *)malloc(sizeof(struct ENode));
        mp->point[firP].outDegree++;
        mp->point[secP].inDegree++;
        newNode->secPoint = secP;
        newNode->weight=weight;
        newNode->next = mp->point[firP].next;
        mp->point[firP].next = newNode;
    }
    return mp;
}

//迪杰斯特拉算法求图中某一顶点到其他顶点的最短路径

void Dijkstra(struct Map *mp,int sourcePoint)
{
    int minPath[20];//记录到各个顶点的最短路径值
    bool known[20]={0};//顶点的最短路径确定后则为真
    int minTmp;//临时变量，作用是选出当前未确定最短路径的顶点中路径长的最小值
    int minE;//记录上一步中的那个顶点
    int i,knownFlag=1;
    struct ENode *tmp;

    known[sourcePoint]=true;
    memset(minPath,1,sizeof(minPath));
    minPath[sourcePoint]=0;

//将能从源顶点到达的顶点的路径长度设定为源顶点到这个顶点的边的权值

    for(tmp=mp->point[sourcePoint].next;tmp!=NULL;tmp=tmp->next)
    {
        minPath[tmp->secPoint]=tmp->weight;
    }
//如果还有顶点的最短路径未确定则循环
    while(knownFlag<=mp->numPoint)
    {

        minTmp=32767;//初始值为最大的整数

//选出选出当前未确定最短路径的顶点中路径长的最小值

//确定这个值就是到这个顶点的最短路径

        for(i=0;inumPoint;i++)
        {
            if(minPath[i]             {
                    minTmp=minPath[i];
                    minE=i;
            }
        }
//置位，累加
        known[minE]=true;
        knownFlag++;

//更新新选出的顶点能够到达的顶点的当前最短路径的值

        for(tmp=mp->point[minE].next;tmp!=NULL;tmp=tmp->next)

        {

//新节点的最短路径加上新节点到自己的权值如果小于自己当前的最短路径值则更新

            if(minPath[minE]+tmp->weightsecPoint])
            {
                minPath[tmp->secPoint]=minPath[minE]+tmp->weight;
            }
        }
    }
    for(i=0;inumPoint;i++)
    {
        printf("%d:%d\n",i,minPath[i]);
    }
}

int main()
{
    struct Map *mp = CreateMap();

    Dijkstra(mp,0);

    return 1;
}