《大话数据结构》图。2018-8-10

prim算法：

1.给一个顶点：v1

2.找v1边中的最小点值v3=1.只判断一个点

3.v3确定。在判断v3连接的其他顶点，如果其他顶点和多个已确定顶点有边，那只保留最小的那条。v2保留5，v4待定。在判断边中值最小的是v6=4。只判断一个点

4.v6确定。在判断v6连接的其他顶点，如果其他顶点和多个已确定顶点有边，那只保留最小的那条。v4=2。

5.v4确定。同理，v2=5是最小的。

6.v2确定。v5最小的是3.完成

代码实现：

void Prim(MGraph G)
{
    int main,i,j,k;
    int adjvex[MAXVEX];    /*保存顶点的下标*/
    int lowcost[MAXVEX];   /*保存权值*/
    adjvex[0]=0;
    lowcost[0]=0;
    for (i=1;i<G.numVertexesli++)
    {
        lowcost[i]=G.arc[0][i];  /*储存0顶点的所有权值*/
        adjvex[i]=0;
    }
    for (i=1;i<G.numVertexes;i++)
    {
        min=INFINIY;   /*初始化*/
        j=1;k=0;
        while(j<G.numVertexes)    /*循环全部顶点*/
        {
            if(lowcost[j]!=0 && locost[j]<min)  /*权值不为0且小于min*/
            {
                min=lowcost[j];
                k=j;
            }
            j++:
        }
        printf("%d,%d",adjvex[k],k);
        lowcost[k]=0;
        for(j=1;j<G.numVertexes;j++)
        {
            if(lowcost[j]!=0 && G.arc[k][j]<lowcost[j])
            {
                lowcost[j]=G.arc[k][j];
                adjvex[j]=k;
            }
        }
    }
}

最短路径：

迪杰斯特拉算法https://www.cnblogs.com/nigang/p/3658990.html

两顶点之间权值路径最短。

#define MAXVEX 9
#define INFINITY 65535
typedef int Pathmatirx[MAXVEX];     /*s存储下标*/
typedef int ShorPathTable[MAXVEX];   /*V存储权值*/

void shortestPath_Dijkstra(MGrapgh G, ShortPathTable *D, Pathmarirx *P, int vo)
{
    int v,w,k,min;
    int final[MAXVEX];  /*final[w]=1表示求得顶点v0至vw的最短路径*/
    for (v=0;v<G.numVertexes;v++)
    {
        final[v]=0;     /*全部顶点初始化为未知最短路径状态*/
        (*D)[v]=G.matirx[v0][v];   /*将与v0点有连线的顶点加上权值*/
        (*P)[v]=0;      /*初始化路径数组P为0*/
    }
    (*D)[v0]=0;          /*v0至v0路径为0*/
    final[v0]=1;         /*v0至v0不需要求路径*/
    for(v=1;v<G.numVertexes;v++)
    {
        min=INFINITY;
        for(w=0;w<G.numVertexes;w++)
        {
            if(!final[w] && (*D)[w]<min)
            {
                k=w;
                min=(*D)[w];
            }
        }
        final[k]=1;
        FOR(W=0;W<G.numVertexes;w++)
        {
            if(!final[w]&&9min+G.matirx[k][w]<(*D)[w])
            {
                (*D)[w]=min+G.matirx[k][w];
                (*p)[w]=k;
            }
        } 
    }
}

佛洛依德算法：