数据结构C语言-最短路径

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int status;
typedef int ElemType;
typedef int bool;
#define true 1
#define false 0

#define MaxInt 32767
#define MVNum 100
typedef char VerTexType;
typedef int ArcType;
typedef struct
{
    VerTexType vexs[MVNum];
    ArcType arcs[MVNum][MVNum];
    int vexnum,arcnum;
}AMGraph;

int LocateVex_AM(AMGraph G,VerTexType v)
{
    int i=0;
    //while(i<G.vexnum&&v!=G.vexs[i])
        //i++;
    for(;i<G.vexnum;i++)
        if(G.vexs[i]==v)
           break;
    return i;
}

status CreateUDN_AM(AMGraph *G,VerTexType *V)
{
    int i,j,k;
    for(i=0;i<G->vexnum;i++)
        G->vexs[i]=V[i];
    for(i=0;i<G->vexnum;i++)
        for(j=0;j<G->vexnum;j++)
        G->arcs[i][j]=MaxInt;
    char v1,v2;
    int w;
    for(k=0;k<G->arcnum;k++)
    {
        scanf("%c %c %d",&v1,&v2,&w);
        getchar();
        int i=LocateVex_AM(*G,v1);
        int j=LocateVex_AM(*G,v2);
        G->arcs[i][j]=w;
        //G->arcs[j][i]=G->arcs[i][j];
    }
    return OK;
}

void printAMG(AMGraph G)
{
    int i,j;
    for(i=0;i<G.vexnum;i++)
    {
        for(j=0;j<G.vexnum;j++)
            printf("%5d ",G.arcs[i][j]);
        printf("\n");
    }
}

void ShortestPath_DIJ(AMGraph G,int v0)
{
    int n=G.vexnum,v,i,w;
    bool S[n];
    int Path[n];
    ArcType D[n];
    for(v=0;v<n;v++)
    {
        S[v]=false;
        D[v]=G.arcs[v0][v];
        if(D[v]<MaxInt)
            Path[v]=v0;
        else
            Path[v]=-1;
    }
    S[v0]=true;
    D[v0]=0;
    //初始化结束
    for(i=1;i<n;i++)
    {
        int min=MaxInt;
        for(w=0;w<n;w++)
            if(!S[w]&&D[w]<min)
            {
                v=w;
                min=D[w];
            }
        S[v]=true;
        for(w=0;w<n;w++)
        {
          if(!S[w]&&(D[v]+G.arcs[v][w])<D[w])
          {
              D[w]=D[v]+G.arcs[v][w];
              Path[w]=v;
          }
        }
    }
    //打印结果
    for(i=0;i<n;i++)
        printf("%d->%d=%d\n",v0,i,D[i]);
}

void ShortestPath_Floyd(AMGraph G)
{
    int n=G.vexnum,Path[n][n],i,j,k;
    ArcType D[n][n];
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            if(i==j)
            {
                D[i][j]=0;
                Path[i][j]=-1;
            }
            else
            {
                D[i][j]=G.arcs[i][j];
                if(D[i][j]<MaxInt)
                   Path[i][j]=i;
                else
                   Path[i][j]=-1;
        }
    //初始化结束
    for(k=0;k<n;k++)
        for(i=0;i<n;i++)
            for(j=0;j<n;j++)
                if(D[i][k]+D[k][j]<D[i][j])
                {
                   D[i][j]=D[i][k]+D[k][j];
                   Path[i][j]=Path[k][j];
                }
    //打印
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
            printf("%2d ",D[i][j]);
        printf("\n");
    }
}

int main()
{
    AMGraph G;
    G.vexnum=4;//DIJ的G为6
    G.arcnum=8;
    VerTexType V[G.vexnum];
    int i;
    for(i=0;i<G.vexnum;i++)
        V[i]=i+'A';
    printf("Create AMGraph:\n");
    CreateUDN_AM(&G,V);
    //printAMG(G);
    printf("ShortestPath_DIJ:\n");
    ShortestPath_DIJ(G,0);
    printf("ShortestPath_Floyd:\n");
    ShortestPath_Floyd(G);
    return 0;
}