数据结构---图---最短路径---5

最新推荐文章于 2022-12-11 22:53:36 发布
最新推荐文章于 2022-12-11 22:53:36 发布
阅读量398 收藏
点赞数
分类专栏： 数据结构 文章标签： 图 c# 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41155760/article/details/121538479
版权

对于非网图，它没有边上的权值，最短路径就是指两顶点之间经过的边数最少的路径。

对于网图，最短路径指两顶点之间经过的边上权值之和最少的路径，称路径上第一个顶点是源点，最后一个顶点是终点。

两种求最短路径的算法：

1.迪杰斯特拉（Dijkstra）算法
2.弗洛伊德（Floyd）算法

迪杰斯特拉（Dijkstra）算法：

//测试数据
int[] vertexs = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
int[,] edges = new int[,]
{
    //0     1       2       3       4     5       6       7     8    
    { 0,    1,      5,      MAX,    MAX,  MAX,    MAX,    MAX,  MAX, },     //0
    { 1,    0,      3,      7,      5,    MAX,    MAX,    MAX,  MAX, },     //1
    { 5,    3,      0,      MAX,    1,    7,      MAX,    MAX,  MAX, },     //2
    { MAX,  7,      MAX,    0,      2,    MAX,    3,      MAX,  MAX, },     //3                                                                               
    { MAX,  5,      1,      2,      0,    3,      6,      9,    MAX, },     //4
    { MAX,  MAX,    7,      MAX,    3,    0,      MAX,    5,    MAX, },     //5
    { MAX,  MAX,    MAX,    3,      6,    MAX,    0,      2,    7,   },     //6   
    { MAX,  MAX,    MAX,    MAX,    9,    5,      2,      0,    4,   },     //7   
    { MAX,  MAX,    MAX,    MAX,    MAX,  MAX,    7,      4,    0,   },     //8     
};

/// <summary>
/// 迪杰斯特拉算法：最短路径
/// 求有向网graph的V0顶点到其余顶点v最短路径pathArr[v]及带权长度shortPath[v]
/// </summary>    
/// <param name="v0">第一个顶点的下标</param>
/// <param name="pathArr">存储最短路径下标的数组</param>
/// <param name="shortPath">存储到各点最短路径的权值和</param>
public void ShortestPath_Dijkstra(int v0, int[] pathArr, int[] shortPath)
{       
    int v, w, k = 0, min;
    int[] final = new int[maxNumVertex];  //final[w]=1表示求得顶点V0至Vw的最短路径
    for (v = 0; v < vertexs.Length; v++)   //初始化数据
    {
        final[v] = 0;                      //全部顶点初始化为未知最短路径状态
        shortPath[v] = edges[v0, v];       //存储V0到每个顶点的最短路径权值之和
        pathArr[v] = 0;                    //初始化路径数组为0，存储顶点v的前驱结点
    }

    pathArr[v0] = 0;        //v0到v0路径为0
    final[v0] = 1;          //v0至v0不需要求路径

    //开始主循环，每次求得v0到某个v顶点的最短路径
    for (v = 1; v < vertexs.Length; v++)
    {
        min = int.MaxValue;
        for (w = 0; w < vertexs.Length; w++)
        {
            if (final[w] == 0 && shortPath[w] < min)
            {
                k = w;
                min = shortPath[w];     //w顶点离v0顶点更近
            }
        }
        final[k] = 1;   //将目前找到的最近的顶点置为1

        for (w = 0; w < vertexs.Length; w++)
        {
            //从V0开始，如果经过k顶点到达w顶点的路径比现在这条路径的长度短的话，更新值。
            //之前最近的点不参与，未连通的点不参与，自身不参与，新的最短路径出现替换原来的值
            if (final[w] == 0 && edges[k, w] != int.MaxValue && edges[k, w] != 0 && (min + edges[k, w] < shortPath[w]))
            {
                //说明找到了更短的路径，shortPath[w]和pathArr[w]
                shortPath[w] = min + edges[k, w];
                pathArr[w] = k; //存储最短路径到达w顶点的前驱顶点k,从V0开始经过k到w最短。
            }
        }
    }
}

通过迪杰斯特拉算法解决了从某个源点到其余各顶点的最短路径问题，从循环嵌套可以很容易得到此算法的时间复杂度为O(n的2次方)。

想知道任一顶点到其余所有顶点的最短路径，就是对每个顶点执行一次迪杰斯特拉算法，等于在原有算法的基础上，再来一次循环，此时算法的时间复杂度为O(n的3次方)。

弗洛伊德（Floyd）算法：求所有顶点到所有顶点的最短路径，时间复杂度为O(n的3次方)
在这里插入图片描述在这里插入图片描述在这里插入图片描述

测试数据和上面的迪杰斯特拉算法一样

/// <summary>
/// 弗洛伊德算法：求网图中各顶点v到其余顶点w最短路径pathMatrix[v,w]及带权长度shortPath[v,w]
/// 传参方式
/// </summary>    
/// <param name="pathMatrix">存储最短路径下标的数组</param>
/// <param name="shortPath">存储到各点最短路径的权值和</param>
public void ShortestPath_Floyd(int[,] pathMatrix, int[,] shortPath)
{
    int v, w, k;
    for (v = 0; v < vertexs.Length; v++)
    {
        for (w = 0; w < vertexs.Length; w++)
        {
            shortPath[v, w] = edges[v, w]; //shortPath[v,w]值即为对应点间的权值
            pathMatrix[v, w] = w;               //初始化pathMatrix
        }
    }

    for (k = 0; k < vertexs.Length; k++)	//k表示中转的顶点, v->k->w
    {
        for (v = 0; v < vertexs.Length; v++)	//v源点
        {
            for (w = 0; w < vertexs.Length; w++)	//w终点
            {
                //v和k不通 或 k和w不通，跳出，此路不通,这里极大值用的是int.MaxValue
                if (shortPath[v, k] == int.MaxValue || shortPath[k, w] == int.MaxValue) continue;

                //如果经过下标为k顶点路径比原两点路径更短，将当前两点权值设为更小的一个
                if (shortPath[v, w] > shortPath[v, k] + shortPath[k, w])
                {
                    shortPath[v, w] = shortPath[v, k] + shortPath[k, w];
                    pathMatrix[v, w] = pathMatrix[v, k];
                }
            }
        }
    }

    //最短路径显示代码
    for (v = 0; v < vertexs.Length; v++)
    {
        for (w = v + 1; w < vertexs.Length; w++)
        {
            Debug.Log("源点:" + v + " 终点:" + w + " weight:" + shortPath[v, w]);

            k = pathMatrix[v, w];               //获得第一个路径顶点下标

            string str = "path:" + v;           //源点

            while (k != w)                      //如果路径顶点下标不是终点
            {
                str += "->" + k;                //路径顶点
                k = pathMatrix[k, w];           //获得下一个路径顶点下标
            }

            str += "->" + w;                    //终点
            Debug.Log(str);
        }
    }
}

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

具体详细步骤请看书！

邻接矩阵源码：遍历、最小生成树、最短路径

/// <summary>
/// 泛型邻接矩阵
/// </summary>
public class AdjacentMatrix<T>
{
    #region 数据
    //数据
    private T[] vertexs;        //顶点数组：数据
    private int[,] edges;       //边数组：权值  
    private int maxNumVertex;   //最大顶点数                              
    #endregion

    #region 操作

    /// <summary>
    /// 创建无向网图的邻接矩阵表示
    /// </summary>    
    /// <param name="vertexs">顶点数据</param>
    /// <param name="edges">边数据：权值</param>   
    public AdjacentMatrix(T[] vertexs, int[,] edges)
    {
        maxNumVertex = vertexs.Length;
        this.vertexs = new T[maxNumVertex];
        this.edges = new int[maxNumVertex, maxNumVertex];
        Array.Copy(vertexs, this.vertexs, vertexs.Length);
        Array.Copy(edges, this.edges, edges.Length);
    }

    /// <summary>
    /// 创建无向网图的邻接矩阵表示
    /// </summary>    
    /// <param name="vertexs">顶点数据</param>
    /// <param name="edges">边数据：权值</param>
    /// <param name="maxNumVertex">最大顶点数组容量</param>
    public AdjacentMatrix(T[] vertexs, int[,] edges, int maxNumVertex)
    {
        maxNumVertex = maxNumVertex < vertexs.Length ? vertexs.Length : maxNumVertex;

        this.vertexs = new T[maxNumVertex];
        this.edges = new int[maxNumVertex, maxNumVertex];
        this.maxNumVertex = maxNumVertex;
        Array.Copy(vertexs, this.vertexs, vertexs.Length);
        Array.Copy(edges, this.edges, edges.Length);
    }

    private bool[] visited;

    /// <summary>
    /// 邻接矩阵的深度优先遍历
    /// </summary>
    /// <param name="gl"></param>
    public void DFSTraverse()
    {
        visited = new bool[maxNumVertex];

        for (int i = 0; i < vertexs.Length; i++)
        {
            visited[i] = false; //初始化所有顶点都是未访问的状态
        }

        for (int i = 0; i < vertexs.Length; i++)
        {
            //对未访问过的顶点调用DFS，若是连通图，只会执行一次
            if (!visited[i])
            {
                DFS(i);
            }
        }
    }

    /// <summary>
    /// 邻接矩阵的深度优先递归算法
    /// </summary>
    /// <param name="gl"></param>
    /// <param name="i"></param>
    private void DFS(int i)
    {
        visited[i] = true;

        //这里对顶点的操作,这里简单的打印
        Debug.Log(vertexs[i]);

        for (int j = 0; j < vertexs.Length; j++)
        {
            //edges[i, j] == 1表示两顶点是连通的
            //如果是权值，可以判断: edges[i,j]!=0 && edges[i,j]! = MaxValue
            //MaxValue自己定，可以用int.MaxValue,long.MaxValue，float.MaxValue等
            //具体权值用int long 还是float自己定
            if (edges[i, j] == 1 && !visited[j])
            {
                DFS(j);
            }
        }
    }

    /// <summary>
    /// 邻接矩阵：广度优先遍历
    /// </summary>
    /// <param name="graph"></param>
    public void BFSTraverse()
    {
        Queue<int> queue = new Queue<int>();  //初始化辅助队列
        visited = new bool[maxNumVertex];

        for (int i = 0; i < vertexs.Length; i++)
        {
            visited[i] = false;
        }

        for (int i = 0; i < vertexs.Length; i++)   //对每一个顶点做循环
        {
            if (!visited[i])            //若是未访问过就处理
            {
                visited[i] = true;      //设置当前顶点访问过

                //这里对顶点的操作,这里简单的打印
                Debug.Log(vertexs[i]);

                queue.Enqueue(i);       //将此顶点入队列

                while (queue.Count > 0) //当前队列有元素
                {
                    i = queue.Dequeue();    //出队列

                    for (int j = 0; j < vertexs.Length; j++)
                    {
                        //edges[i, j] == 1表示两顶点是连通的
                        //如果是权值，可以判断: edges[i,j]!=0 && edges[i,j]! = MaxValue
                        //MaxValue自己定，可以用int.MaxValue,long.MaxValue，float.MaxValue等
                        //具体权值用int long 还是float自己定
                        if (edges[i, j] == 1 && !visited[j])
                        {
                            visited[j] = true;

                            //这里对顶点的操作,这里简单的打印
                            Debug.Log(vertexs[j]);

                            queue.Enqueue(j);
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// 普里姆算法：最小生成树
    /// </summary>    
    public void MiniSpanTree_Prim()
    {
        int minWeight, i, j, minWeightIndex;
        int[] adjvex = new int[vertexs.Length];    //保存相关顶点下标
        int[] lowWeight = new int[vertexs.Length];   //保存相关顶点间边的权值
        lowWeight[0] = 0;     //初始化第一个权值为0，即V0加入生成树，lowCost的值为0，在这里就是此下标的顶点已经加入生成树
        adjvex[0] = 0;        //初始化第一个顶点下标为0，从顶点V0开始

        //读取第一行，初始化
        for (i = 1; i < vertexs.Length; i++)   //循环除下标为0外的全部顶点
        {
            lowWeight[i] = edges[0, i];     //将V0顶点与之有边的权值存入数组
            adjvex[i] = 0;                  //初始化都为V0的下标
        }

        //构造最小生成树
        for (i = 1; i < vertexs.Length; i++)
        {
            minWeight = int.MaxValue;   //初始化最小权值为极大值，通常设置为不可能的大数字，如：32765、65535等
            j = 1;                      //顶点下标循环变量
            minWeightIndex = 0;         //用来存储最小权值的顶点下标

            //遍历每一行的数据
            while (j < vertexs.Length)
            {
                if (lowWeight[j] != 0 && lowWeight[j] < minWeight)
                {
                    minWeight = lowWeight[j];       //让当前权值成为最小值
                    minWeightIndex = j;             //将当前最小值的下标存入k
                }
                j++;
            }

            Debug.Log("打印当前顶点边中权值最小边：" + adjvex[minWeightIndex] + "---" + minWeightIndex);

            lowWeight[minWeightIndex] = 0;     //将当前顶点的权值设置为0，表示此顶点已经完成任务

            for (j = 1; j < vertexs.Length; j++)       //循环所有顶点
            {
                if (lowWeight[j] != 0 && edges[minWeightIndex, j] < lowWeight[j])
                {
                    //若下标为k顶点各边权值小于此前这些顶点未被加入生成树权值
                    lowWeight[j] = edges[minWeightIndex, j];         //将较小权值存入lowCost
                    adjvex[j] = minWeightIndex;                      //将下标为k的顶点存入adjvex
                }
            }
        }
    }

    /// <summary>
    /// 迪杰斯特拉算法：最短路径,返回元组，不用传参
    /// 求有向网graph的V0顶点到其余顶点v最短路径pathArr[v]及带权长度shortPath[v]
    /// </summary>    
    /// <param name="v0">第一个顶点的下标</param>  
    public (int[], int[]) ShortestPath_Dijkstra(int v0)
    {
        int v, w, k = 0, min;
        int[] pathArr = new int[vertexs.Length];        //存储最短路径下标的数组
        int[] shortPath = new int[vertexs.Length];      //存储到各点最短路径的权值和

        int[] final = new int[maxNumVertex];  //final[w]=1表示求得顶点V0至Vw的最短路径
        for (v = 0; v < vertexs.Length; v++)   //初始化数据
        {
            final[v] = 0;                      //全部顶点初始化为未知最短路径状态
            shortPath[v] = edges[v0, v];       //存储V0到每个顶点的最短路径权值之和
            pathArr[v] = 0;                    //初始化路径数组为0，存储顶点v的前驱结点
        }

        pathArr[v0] = 0;        //v0到v0路径为0
        final[v0] = 1;          //v0至v0不需要求路径

        //开始主循环，每次求得v0到某个v顶点的最短路径
        for (v = 1; v < vertexs.Length; v++)
        {
            min = int.MaxValue;
            for (w = 0; w < vertexs.Length; w++)
            {
                if (final[w] == 0 && shortPath[w] < min)
                {
                    k = w;
                    min = shortPath[w];     //w顶点离v0顶点更近
                }
            }
            final[k] = 1;   //将目前找到的最近的顶点置为1

            for (w = 0; w < vertexs.Length; w++)
            {
                //从V0开始，如果经过k顶点到达w顶点的路径比现在这条路径的长度短的话，更新值。
                //之前最近的点不参与，未连通的点不参与，自身不参与，新的最短路径出现替换原来的值
                if (final[w] == 0 && edges[k, w] != int.MaxValue && edges[k, w] != 0 && (min + edges[k, w] < shortPath[w]))
                {
                    //说明找到了更短的路径，shortPath[w]和pathArr[w]
                    shortPath[w] = min + edges[k, w];
                    pathArr[w] = k; //存储最短路径到达w顶点的前驱顶点k,从V0开始经过k到w最短。
                }
            }
        }

        return (pathArr, shortPath);  //返回结果，这里用的C#元组语法
    }

    /// <summary>   
    /// 迪杰斯特拉算法：最短路径,传统传参方式
    /// 求有向网graph的V0顶点到其余顶点v最短路径pathArr[v]及带权长度shortPath[v]
    /// </summary>
    /// <param name="v0">第一个顶点的下标</param>
    /// <param name="pathArr">存储最短路径下标的数组</param>
    /// <param name="shortPath">存储到各点最短路径的权值和</param>  
    public void ShortestPath_Dijkstra(int v0, int[] pathArr, int[] shortPath)
    {
        int v, w, k = 0, min;
        int[] final = new int[maxNumVertex];  //final[w]=1表示求得顶点V0至Vw的最短路径
        for (v = 0; v < vertexs.Length; v++)   //初始化数据
        {
            final[v] = 0;                      //全部顶点初始化为未知最短路径状态
            shortPath[v] = edges[v0, v];       //存储V0到每个顶点的最短路径权值之和
            pathArr[v] = 0;                    //初始化路径数组为0，存储顶点v的前驱结点
        }

        pathArr[v0] = 0;        //v0到v0路径为0
        final[v0] = 1;          //v0至v0不需要求路径

        //开始主循环，每次求得v0到某个v顶点的最短路径
        for (v = 1; v < vertexs.Length; v++)
        {
            min = int.MaxValue;
            for (w = 0; w < vertexs.Length; w++)
            {
                if (final[w] == 0 && shortPath[w] < min)
                {
                    k = w;
                    min = shortPath[w];     //w顶点离v0顶点更近
                }
            }
            final[k] = 1;   //将目前找到的最近的顶点置为1

            for (w = 0; w < vertexs.Length; w++)
            {
                //从V0开始，如果经过k顶点到达w顶点的路径比现在这条路径的长度短的话，更新值。
                //之前最近的点不参与，未连通的点不参与，自身不参与，新的最短路径出现替换原来的值
                if (final[w] == 0 && edges[k, w] != int.MaxValue && edges[k, w] != 0 && (min + edges[k, w] < shortPath[w]))
                {
                    //说明找到了更短的路径，shortPath[w]和pathArr[w]
                    shortPath[w] = min + edges[k, w];
                    pathArr[w] = k; //存储最短路径到达w顶点的前驱顶点k,从V0开始经过k到w最短。
                }
            }
        }
    }

    /// <summary>
    /// 弗洛伊德算法：求网图中各顶点v到其余顶点w最短路径pathMatrix[v,w]及带权长度shortPath[v,w]
    /// 传参方式
    /// </summary>    
    /// <param name="pathMatrix">存储最短路径下标的数组</param>
    /// <param name="shortPath">存储到各点最短路径的权值和</param>
    public void ShortestPath_Floyd(int[,] pathMatrix, int[,] shortPath)
    {
        int v, w, k;
        for (v = 0; v < vertexs.Length; v++)
        {
            for (w = 0; w < vertexs.Length; w++)
            {
                shortPath[v, w] = edges[v, w]; //shortPath[v,w]值即为对应点间的权值
                pathMatrix[v, w] = w;               //初始化pathMatrix
            }
        }

        for (k = 0; k < vertexs.Length; k++)
        {
            for (v = 0; v < vertexs.Length; v++)
            {
                for (w = 0; w < vertexs.Length; w++)
                {
                    //v和k不通 或 k和w不通，跳出，此路不通
                    if (shortPath[v, k] == int.MaxValue || shortPath[k, w] == int.MaxValue) continue;

                    //如果经过下标为k顶点路径比原两点路径更短，将当前两点权值设为更小的一个
                    if (shortPath[v, w] > shortPath[v, k] + shortPath[k, w])
                    {
                        shortPath[v, w] = shortPath[v, k] + shortPath[k, w];
                        pathMatrix[v, w] = pathMatrix[v, k];
                    }
                }
            }
        }

        //最短路径显示代码
        for (v = 0; v < vertexs.Length; v++)
        {
            for (w = v + 1; w < vertexs.Length; w++)
            {
                Debug.Log("源点:" + v + " 终点:" + w + " weight:" + shortPath[v, w]);

                k = pathMatrix[v, w];               //获得第一个路径顶点下标

                string str = "path:" + v;           //源点

                while (k != w)                      //如果路径顶点下标不是终点
                {
                    str += "->" + k;                //路径顶点
                    k = pathMatrix[k, w];           //获得下一个路径顶点下标
                }

                str += "->" + w;                    //终点
                Debug.Log(str);
            }
        }
    }

    /// <summary>
    /// 弗洛伊德算法：求网图中各顶点v到其余顶点w最短路径pathMatrix[v,w]及带权长度shortPath[v,w]
    /// 元组形式
    /// </summary>   
    /// <param name="pathMatrix">存储最短路径下标的数组</param>
    /// <param name="shortPath">存储到各点最短路径的权值和</param>
    public (int[,], int[,]) ShortestPath_Floyd()
    {
        int[,] pathMatrix = new int[vertexs.Length, vertexs.Length];
        int[,] shortPath = new int[vertexs.Length, vertexs.Length];

        int v, w, k;
        for (v = 0; v < vertexs.Length; v++)
        {
            for (w = 0; w < vertexs.Length; w++)
            {
                shortPath[v, w] = edges[v, w]; //shortPath[v,w]值即为对应点间的权值
                pathMatrix[v, w] = w;               //初始化pathMatrix
            }
        }

        for (k = 0; k < vertexs.Length; k++)
        {
            for (v = 0; v < vertexs.Length; v++)
            {
                for (w = 0; w < vertexs.Length; w++)
                {
                    //v和k不通 或 k和w不通，跳出，此路不通
                    if (shortPath[v, k] == int.MaxValue || shortPath[k, w] == int.MaxValue) continue;

                    //如果经过下标为k顶点路径比原两点路径更短，将当前两点权值设为更小的一个
                    if (shortPath[v, w] > shortPath[v, k] + shortPath[k, w])
                    {
                        shortPath[v, w] = shortPath[v, k] + shortPath[k, w];
                        pathMatrix[v, w] = pathMatrix[v, k];
                    }
                }
            }
        }

        //最短路径显示代码
        for (v = 0; v < vertexs.Length; v++)
        {
            for (w = v + 1; w < vertexs.Length; w++)
            {
                Debug.Log("源点:" + v + " 终点:" + w + " weight:" + shortPath[v, w]);

                k = pathMatrix[v, w];               //获得第一个路径顶点下标

                string str = "path:" + v;           //源点

                while (k != w)                      //如果路径顶点下标不是终点
                {
                    str += "->" + k;                //路径顶点
                    k = pathMatrix[k, w];           //获得下一个路径顶点下标
                }

                str += "->" + w;                    //终点
                Debug.Log(str);
            }
        }

        return (pathMatrix, shortPath);
    }
    #endregion
}
牛神自
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】什么是图的最短路径？实现最短路径的2种算法？
四季轮换叶，一路招摇胜
10-07 7391
最短路径问题是指在一个赋权图的两个节点之间找出一个具有最小权的路径。旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。
数据结构（六）——图之最短路径
Double___H的博客
07-04 568
代码中所用到的结构体 typedef struct arccell { int adj;//权值 char *info; }ArcCell,AdjMatrix[MAX][MAX]; typedef struct { int vexs[MAX];//结点数据 AdjMatrix arcs; int vexnum,arcnum;//图的点数和边数 Gr...
数据结构之图最短路径
风间琉璃の博客
05-16 6790
1. 最短路径（Shortest Path） 两顶点之间权值之和最小的路径。无权图相当于每条边的权值都是1。 不能有负权环。 有向图的最短路径： 从顶点A出发到达其它顶点的最短路径如下表：无法到达的顶点以∞表示 无向图的最短路径： 也是以A顶点为起点到达其它顶点的最短路径： 无权图的最短路径： 即把每条边的权值都作为1来看： 负权边：只有不存在负权环时才有最短路径。 -负权环：不存在最短路径，如果一种绕环，路径值可以达到无穷小。 1.1 Dijkstra（迪杰斯特拉算法） 1
图的最短路径--数据结构
m0_65768173的博客
12-11 2098
一文搞定最短路径
【数据结构-图】3.图的最短路径的几种算法（图解+演绎）
为了远大的理想，冲锋！
02-08 1万+
最短路径 最短路径的求取有两种经典的算法，分别是Dijkstra算法和Floyd算法 这Dijkstra算法的算法思想是基于贪心算法的，也就是选择权值最小的边 而Floyd算法的算法思想是根据动态规划，不断迭代取得的 Dijkstra算法：从顶点出发，优先选择与连接两个顶点集合中的权值最小的边，求单源最短路径 Floyd算法：求多源最短路径，不断迭代列表中的数据 Dijkstra Dijkstra算法的核心是实时更新三个列表信息构成的 —— 这与最小生成树中的Prim算法相似 第一个列表visited，是
数据结构篇十九：图的最短路径
Dzp199903的博客
03-25 662
图的最短路径 迪杰斯特拉算法 贝尔曼-福特算法 弗洛伊德算法 SPFA算法(中国西南交通大学段凡丁发明) 最短路径问题分为两类，一大类是求一个顶点到其余各顶点的最短路径问题，另一大类是求各个顶点间最短路径问题。 迪杰斯特拉 迪杰斯特拉算法就是求解一个点到其余各点的最短路径算法，无向图带权图和有向带权图都适用。缺点是不适用权值为负数的图(后面会讲解原因) 算法步骤 初始的点为起点，我们用s集合存储已经确定最短路径的点的集合，那么s={v},起点加入。其余各个点到v点的权值存储在dis数组里，不是
图-最短路径-可视化.zip
01-02
在IT领域，图算法是数据结构与算法中的一个重要部分，主要用来解决网络中节点间的关系问题，例如在交通网络、社交网络或者计算机网络中的路径寻找等。本项目以"图-最短路径-可视化.zip"为主题，利用Java编程语言实现...
zuiduanlujing.rar_最短路径c-c
09-24
1. 图的数据结构：可以使用邻接矩阵或邻接表来表示图。邻接矩阵适合表示稠密图，邻接表适合表示稀疏图，根据实际问题选择合适的表示方式。 2. 节点和边的定义：定义结构体来表示节点和边，包括节点的编号、距离信息...
zuiduanlujing.rar_C语言 最短路径_最短路径c-c
09-24
5. **主循环**：算法的核心是不断更新最短路径信息，直到没有节点可以进一步缩短路径或者遍历了所有节点。 6. **结果输出**：最后，程序应能输出最短路径及其长度，可能是通过打印或保存到文件。 压缩包中的“最短...
数据结构实验-图-求最短路径
01-12
在这个数据结构实验中，主要关注的是如何在图中寻找最短路径。实验要求使用字符文件作为数据源，构建一个带权重的网络存储结构，并通过C++编程实现算法。实验的目标是掌握图的存储结构和最短路径算法，特别是迪杰...
西安工业大学-数据结构课设-最短路径
最新发布
08-10
在这个西安工业大学的“数据结构”课程设计中，我们聚焦于一个经典的问题：计算图中两点之间的最短路径。这个问题在实际应用中有着广泛的应用，比如交通网络规划、路由选择以及网络优化等。 首先，我们需要了解图的...
数据结构笔记13-最短路径
qq_43632507的博客
12-02 370
在非网图中，最短路径是指两顶点之间经历的边数最少的路径。 在网图中，最短路径是指两顶点之间经历的边上权值之和最短的路径。 Dijkstra算法 基本思想： 1、设置一个集合S存放已经找到最短路径的顶点，S的初始状态只包含源点v， 2、对vi∈V-S，假设从源点v到vi的有向边为最短路径（从v到其余顶点的最短路径的初 值）。 3、以后每求得一条最短路径v, …, vk，就将vk加入集合S中，并将...
数据结构之图(八)——最短路径问题
daocaoren_的博客
08-08 4871
最短路径问题抽象 典型用途：交通网络问题——从甲地到乙地是否有公路连通？在有许多条公路连通的情况下，哪一条最短？ 交通网络用有向网表示： 顶点——表示地点 弧——表示两个地点有路连通 弧上的权值——表示两地点之间的距离、交通费或途中所花费的时间的等。 如何能够使一个地点到另一个地点的运输时间最短或运费最省？这就是一个求两个地点的最短路径问题。 问题抽象： 在有向网中A点(源点)到达B点...
数据结构——图的最短路径
weixin_55653836的博客
03-02 948
用有向网来表示交通网络，其中顶点表示地点，弧表示两个地点有路连通，弧上的权值表示两地点之间的距离或交通费或途中所花费的时间等等，最短路径就是寻找各边权值之和最小的路径。 最短路径与最小生成树不同，路径上不一定包含n个顶点，也不一定包含n-1条边。 第一类问题：两点间最短路径 迪杰斯特拉算法（时间复杂度O（））： 1、初始化：先找出从源点到各终点的直达路径（，），即通过一条弧到达的路径，若需通过两条或以上的弧则将距离记为无穷远，将全部顶点分为两个集合：S（以求出的最短路径的顶点的集合）和T（尚未确定最
数据结构 | 图的最短路径 Dijkstra算法
鷾
12-17 1468
图的最短路径 Dijkstra算法
无向图的一节点到另一节点的最短路径（边数最少的路径）（采用邻接表存储）...
pleasetojava
11-05 840
// 无向图的一节点到另一节点的最短路径（边数最少的路径）（采用邻接表存储）.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; #define MAX 100 #define MAXQ 50 using namespace ...
数据结构-图详解（最短路径问题-Dijkstra，Bellman-Ford，Floyd-Warshall算法 -C++）
dodamce的博客
07-23 2430
源节点到结点P的代价(代价为0)与P点到adjoinPoint的代价和（5+0和10+0）与源节点到adjoinPoint代价（无穷（默认值））相比要小，根据上面的过程分析，需要将源节点到adjoinPoint的代价更新为源节点到P与P到adjoinPoint的代价之和。第三次，先从Q组找一个起点到源节点路径最小的节点P，P点就是图中的z点。P点相邻的节点有x，s点，源节点到x点距离根据上图可知为14，源节点到P与P到x代价和为7+6=13，两者相比把小的更新到源节点到x代价即可。......
[数据结构]--图(图的遍历,最小生成树,最短路径算法)
热门推荐
Chauncey的博客
10-31 1万+
前言在这里,如果大家对图或者数据结构还不太熟悉,想找一个动态的生成过程来参考,这是一个不错的网站.知识框架图的定义在线性结构中，数据元素之间满足唯一的线性关系，每个数据元素(除第一个和最后一个外)只有一个直接前趋和一个直接后继；在树形结构中，数据元素之间有着明显的层次关系，并且每个数据元素只与上一层中的一个元素(双亲节点)及下一层的多个元素(孩子节点)相关；而在图形结构中，节点之间的关系是任意的，图
《现代通信网》实验十一-NGN本局数据配置.pptx
11-02
OSPF（Open Shortest Path First，开放最短路径优先）协议的基本原理和实验，用于动态路由选择，确保数据包在IP网络中的高效传输。同时，还涉及了ACL（Access Control List，访问控制列表），用于网络安全和流量管理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值