最短路径

最短路径

迪杰斯特拉算法（Dijkstra）

1. 基本思想

它不是一下子求出最短路径，而是一步步求出它们之间顶点的最短路径，过程中都是基于已经求出的最短路径的基础上，求得最远顶点的最短路径，最终得到想要的结果。

2. 代码

#define MAXVEX 9
#define INFINITY 65535
typedef int Patharc[MAXVEX];       //存储最短路径下标的数组
typedf int ShortPathTable[MAXVEX]; //存储到各点最短路径的权值和

//求有向网G的v0顶点到其余顶点v最短路径P[v]及带权长度D[v] P[v]的值为前驱顶点下标D[v]表示v0到v的最短路径长度和
void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D)
{
    int v, w, k, min;
    int final[MAXVEX];            //final[w] = 1表示求得顶点v0至vw的最短路径
    for(v = 0; v < G.numVertexes; i++)
    {
        final[v] = 0;            //全部顶点初始化为未知最短路径状态
        (*D) [v] = G.arc[v0][v]; //将与v0点有连线的顶点加上权值
        (*P) [v] = 0;
    }
    (*D) [v0] = 0;              //v0至v0路径为0
    final[v0] = 1;             //v0至v0不需要求路径
    //开始主循环 每次求得v0到某个v顶点的最短路径
    for(v = 1; v < G.numVertexes; v++)
    {
        min = INFINITY;
        for(w = 0; w < G.numVertexes; w++) //寻找离v0最近的顶点
        {
            if(!final[w] && (*D) [w] < min)
            {
                k = w;
                min = (*D) [w]; //w顶点离v0顶点更近
            }
        }
        final[k] = 1; //将目前找到的最近的顶点置为1
        for(w = 0; w < G.numVertexes; w++) //修正当前最短路径及距离
        {
             //如果经过v顶点的路径比现在在这条路径的长度短的话
            if(!final[w] && (min + G.arc[k][w] < (*D) [w]))
            {
               //说明找到了更短的路径 修改D[w]和P[w]
                (*D) [w] = min + G.arc[k][w]; //修改当前路径长度
                (*P) [w] = k; //存放前驱顶点
            }
        }
    }
}

3. 详解

时间复杂度O(n ^ 2)

迪杰斯特拉算法详解

弗洛伊德算法（Floyd）

1.对比

时间复杂度O(n ^ 3)
迪杰斯特拉算法是求的一个顶点到所有顶点的最短路径，而弗洛伊德算法求的是所有顶点到所有顶点的最短路径

2. 代码

typedef int Pathtirx[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

//Floyd算法 求网图G中各顶点v到其余顶点w最短路径P[v][w]及带权长度D[v][w]
void ShortestPath_Floyd(MGraph G, Pathmatirx *P, ShortPathTable *D)
{
    int v, w, k;
    for(v = 0; v < G.numVertexes; ++v)
    {
        for(w = 0; w < G.numVertexes; ++w)
        {
            (*D) [v][w] = G.matirx[v][w]; //D[v][w]值即为对应点间的权值
            (*P) [v][w] = w;
        }
    }
    for(k = 0; k < G.numVertexes; ++k)
    {
        for(v = 0; v < G.numVertexes; ++v)
        {
            for(w = 0; w < G.numVertexes; ++w)
            {
                if((*D)[v][w] > (*D)[v][k] + (*D)[k][w])
                {
                    //如果经过下标为k顶点路径比原两点间路径更短 将当前两点间权值设为更小的一个
                    (*D)[v][w] = (*D)[v][k] + (*D)[k][w];
                    (*P)[v][w] = (*P)[v][k]; //路径设置经过下标为k的顶点
                }
            }
        }
    }
}

3. 详解

弗洛伊德算法