无向图最短路径算法(C#)实现

最新推荐文章于 2024-07-29 15:51:48 发布
最新推荐文章于 2024-07-29 15:51:48 发布
阅读量1.2w 收藏 19
点赞数 9
分类专栏： .net 算法 文章标签： 算法 c# string distance path null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sloder/article/details/7548214
版权
.net 同时被 2 个专栏收录
11 篇文章 0 订阅
订阅专栏
算法
2 篇文章 0 订阅
订阅专栏

   关于最短距离算法最多莫过于Dijkstra算法。能找到例子不多。书上能看到的代码大多数伪代码。
而在网上看到多代码大多是C或者C++版本，而且大多没有提供完整的代码。C#的版本也找不到，故偶自己写了些代码(权值无负值).

    书上讲的Dijkstra算法看的不太懂，大致的意思是扩散求值的算法，即从源节点一步一步求最短路径的方法。即先找到源节点到其子节点的最短距离，然后再找源节点到其二级孙级点最短距离。如此一步一步直到扩散到目标节点为止。
    先看下我构造的节点图，如下，一开始我是想求A－K的最短路径
   

       以下我构造的一些类和方法

      节点类：     

       /// <summary>
        /// 节点类
        /// </summary>
        class GNode
        {
            public string Name ;
            public List<DNode> LD;  
            public int Rank;
            public int MinDist = 0;
            public string Path = "";
            public bool BFind = false;            
            public GNode(string name) {
                this.Name = name;
                LD = new List<DNode>();                
                Rank = -1;
            }
            /// <summary>
            /// 设置节点级别
            /// </summary>
            /// <param name="parentNode"></param>
            public void SetRank(GNode parentNode)
            {               
                if (Rank == -1)
                {
                    if (parentNode != null)
                        Rank = parentNode.Rank + 1;
                    else
                        Rank = 0;
                }
            }
            public int GetRank()
            {
                return Rank;
            }
        }

           边类      

       /// <summary>
        /// 边类，此处为没有标明边的方向。
        /// </summary>
        class DNode
        {
            string Name;
            public int Distance;
            public GNode CurrNode;
            public DNode(string name,int dist) {
                this.Name = name;
                Distance = dist;
                CurrNode = ht[name] as GNode;
                
            }
        }

      初始化节点,以上代码中的ht为节点的Hashtable集合，节点信息都存放在Hashtable中

      

      private void InitNodes()
      { 
            ///初始化
            ///
            ht= new Hashtable();
            GNode dnTemp = new GNode("A");
            ht.Add("A", dnTemp);
            dnTemp = new GNode("B");
            ht.Add("B", dnTemp);
            dnTemp = new GNode("C");
            ht.Add("C", dnTemp);
            dnTemp = new GNode("D");
            ht.Add("D", dnTemp);
            dnTemp = new GNode("E");
            ht.Add("E", dnTemp);
            dnTemp = new GNode("F");
            ht.Add("F", dnTemp);
            dnTemp = new GNode("G");
            ht.Add("G", dnTemp);
            dnTemp = new GNode("H");
            ht.Add("H", dnTemp);
            dnTemp = new GNode("I");
            ht.Add("I", dnTemp);
            dnTemp = new GNode("J");
            ht.Add("J", dnTemp);
            dnTemp = new GNode("K");
            ht.Add("K", dnTemp);
            dnTemp = new GNode("L");
            ht.Add("L", dnTemp);

            dnTemp = ht["A"] as GNode;
            dnTemp.LD.Add(new DNode("B", 3));
            dnTemp.LD.Add(new DNode("C", 5));
            dnTemp.LD.Add(new DNode("D", 2));

            dnTemp = ht["B"] as GNode;
            dnTemp.LD.Add(new DNode("A", 3));
            dnTemp.LD.Add(new DNode("C", 4));
            dnTemp.LD.Add(new DNode("E", 10));

            dnTemp = ht["C"] as GNode;
            dnTemp.LD.Add(new DNode("A", 5));
            dnTemp.LD.Add(new DNode("B", 4));
            dnTemp.LD.Add(new DNode("D", 2));
            dnTemp.LD.Add(new DNode("G", 6));
            dnTemp.LD.Add(new DNode("F", 1));

            dnTemp = ht["D"] as GNode;
            dnTemp.LD.Add(new DNode("A", 2));
            dnTemp.LD.Add(new DNode("C", 2));
            dnTemp.LD.Add(new DNode("H", 3));

            dnTemp = ht["E"] as GNode;
            dnTemp.LD.Add(new DNode("B", 10));
            dnTemp.LD.Add(new DNode("F", 4));
            dnTemp.LD.Add(new DNode("I", 2));

            dnTemp = ht["F"] as GNode;
            dnTemp.LD.Add(new DNode("C", 1));
            dnTemp.LD.Add(new DNode("E", 4));
            dnTemp.LD.Add(new DNode("K", 8));
            dnTemp.LD.Add(new DNode("L", 2));

            dnTemp = ht["G"] as GNode;
            dnTemp.LD.Add(new DNode("H", 8));
            dnTemp.LD.Add(new DNode("C", 6));
            dnTemp.LD.Add(new DNode("L", 2));

            dnTemp = ht["H"] as GNode;
            dnTemp.LD.Add(new DNode("G", 8));
            dnTemp.LD.Add(new DNode("D", 3));

            dnTemp = ht["I"] as GNode;
            dnTemp.LD.Add(new DNode("J", 1));
            dnTemp.LD.Add(new DNode("E", 2));
            dnTemp.LD.Add(new DNode("K", 6));

            dnTemp = ht["J"] as GNode;
            dnTemp.LD.Add(new DNode("I", 1));
            dnTemp.LD.Add(new DNode("K", 9));

            dnTemp = ht["K"] as GNode;
            dnTemp.LD.Add(new DNode("F", 8));
            dnTemp.LD.Add(new DNode("I", 6));
            dnTemp.LD.Add(new DNode("J", 9));
            dnTemp.LD.Add(new DNode("L", 5));

            dnTemp = ht["L"] as GNode;
            dnTemp.LD.Add(new DNode("G", 2));
            dnTemp.LD.Add(new DNode("F", 2));
            dnTemp.LD.Add(new DNode("K", 5));
        }

       初始化各节点的相对于源节点的级别
      
        /// <summary>
        /// 初始化点阵的Rank
        /// </summary>
        /// <param name="srcs"></param>
        private void InitRank(List<GNode> srcs)
        {
            List<GNode> nextNode=new List<GNode>();
            foreach (GNode src in srcs)
            {
                foreach (DNode dn in src.LD)
                {
                    dn.CurrNode.SetRank(src);
                    if (dn.CurrNode.Rank == (src.Rank + 1) && !nextNode.Contains(dn.CurrNode))
                        nextNode.Add(dn.CurrNode);
                }
            }
            if (nextNode.Count > 0)
                InitRank(nextNode);
        }
            

        单点的最短路径递归方法        

        /// <summary>
        /// 寻找起始节点到目标节点的最小路径，此处采用递归查找。目标节点固定，起始节点递归。
        /// </summary>
        /// <param name="src">起始节点，为临时递归节点</param>
        /// <param name="dest">查找路径中的目标节点</param>
        /// <param name="minx">当前查找最小路径值，此值在递归中共享</param>
        /// <param name="startDist">当前节点以src节点的距离</param>
        /// <param name="srcRank">源节点src的级别</param>
        /// <param name="path">查找中经过的路径</param>
        /// <returns></returns>
        private string FindMinx(GNode src,GNode dest,ref int minx,int startDist,int srcRank,string path)
        {
           // string[] paths=
            int sRank = src.Rank;// dest.GetRank();
            int tmpLength,tmpRank;
            string tmpPath=null;
            string goalPath="";
            string tmpPath1,tmpPath2,tmpNodeName;
            tmpPath1=","+path+",";
            tmpPath2=","+src.Path+",";            
            foreach (DNode dn in src.LD)
            {
                tmpPath = path;
                dn.CurrNode.SetRank(src);
                tmpRank = dn.CurrNode.Rank;
                tmpNodeName = "," + dn.CurrNode.Name + ",";
                //扩散级别大于等于目标级别并且是未走过的节点。
                // had delete tmpRank >= srcRank
                //if (tmpRank >＝ srcRank && path.IndexOf(dn.CurrNode.Name) == -1 && src.Path.IndexOf(dn.CurrNode.Name)==-1)
                if (tmpRank > srcRank && tmpPath1.IndexOf(tmpNodeName) == -1 && tmpPath2.IndexOf(tmpNodeName) == -1)
                {
                    tmpLength = dn.Distance + startDist;                    
                    if (dn.CurrNode.Equals(dest))
                    {
                        if (minx > tmpLength)
                        {
                            minx = tmpLength;
                            tmpPath += "," + dn.CurrNode.Name;
                            goalPath = tmpPath;
                        }
                        else if (minx == tmpLength)
                        {
                            tmpPath += "," + dn.CurrNode.Name;
                            goalPath = tmpPath;
                        }
                    }
                    else
                    {
                        if (tmpLength < minx)//路程小于最小值，查询下个子节点
                        {
                            tmpPath += "," + dn.CurrNode.Name;
                            tmpPath = FindMinx(dn.CurrNode, dest, ref minx, tmpLength, srcRank, tmpPath);
                            if (tmpPath != "")
                                goalPath = tmpPath;
                        }
                    }
                    
                }                
            }
            return goalPath;
        }
       查找最短路径(Route)方法，此处同样使用了递归算法，即算出子节点的最短路径后再算子节点的子节点的最短路径
       
 private bool FindMin(List<GNode> srcs, GNode dest)
        {            
            string tmpPath;
            int destRank = dest.GetRank();
            int tempDestRank;            
            int  minLen=0;           
            bool isFind = false;
            List<GNode> nextNodes = new List<GNode>();
                foreach (GNode src in srcs)
                {
                    if (src.Equals(dest)) return false;
                    foreach (DNode dn in src.LD)
                    {     
                        tempDestRank = dn.CurrNode.Rank;                       
                        if (tempDestRank == (src.Rank + 1))
                        {
                            if(!nextNodes.Contains(dn.CurrNode))
                            {
                                nextNodes.Add(dn.CurrNode);
                            }
                            dn.CurrNode.MinDist = src.MinDist + dn.Distance;
                            if (dn.CurrNode.Equals(dest))
                            {
                                minLen = src.MinDist + dn.Distance;
                                isFind = true;
                                //break;
                            }
                        }                       
                    }
                }
                if (isFind)
                {                    
                    foreach (GNode src in srcs)
                    {
                        tmpPath=FindMinx(src, dest, ref minLen, src.MinDist,src.Rank, "");
                        if (tmpPath != "")
                        {
                            dest.Path = src.Path + tmpPath;
                            dest.MinDist = minLen;
                        }
                    }
                }
                else
                {                  
                    
                    foreach (GNode goal in nextNodes)
                    {
                        minLen = -1;
                        foreach (GNode src in srcs)
                        {
                            if (minLen == -1) minLen = goal.MinDist;
                            tmpPath = FindMinx(src, goal, ref minLen, src.MinDist, src.Rank, "");
                            if (tmpPath != "")
                            {
                                //dn.CurrNode.BFind = true;
                                goal.Path = src.Path + tmpPath;
                                goal.MinDist = minLen;
                            }
                        }
                    }
                    FindMin(nextNodes, dest);
                }              


            return isFind;
        }

     调用与显示结果

    

            InitNodes();
            string start, end;
            if ((start=tbStart.Text.Trim()) == "") return;
            if ((end=tbEnd.Text.Trim()) == "") return;            
            gnStart = ht[start] as GNode;
            gnEnd = ht[end] as GNode;
            if (gnStart == null || gnEnd == null)
            {
                MessageBox.Show("开始节点或结尾节点不正确！");
                return;
            }
            gnStart.SetRank(null);
            gnStart.BFind = true;     
            List<GNode> arrGN=new List<GNode>();
            arrGN.Add(gnStart);
            InitRank(arrGN);
            FindMin(arrGN, gnEnd);            
            tbContent.Text = gnEnd.MinDist.ToString()+"\r\n"+gnEnd.Path;//在界面显示结果


  

sloder
关注
  • 9
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C# 最短路径问题——Dijkstra（二叉堆优化）
Gatongone的博客
09-08 1408
Description 平面上有n个点(N<=100)，每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点直线的距离。现在的任务是找出从一点到另一点之间的最短路径。 Input 输入文件short.in，共有n+m+3行，其中： 第一行为一个整数n。 第2行到第n+1行（共n行），每行的两个整数x和y，描述一个点的坐标(以一个空格隔开)。 第n+2行为一个整数m，表示图中的连线个数。 此后的m行，每行描述一条连
求解无向图中任意两点之间的所有路径的C#实现
10-30
求解无向图中任意两点之间的所有路径的C#实现 本文档只是根据网上搜到的资料，翻译成C#版本。当初为了项目需要，在网上找了很长时间，另外 自己也曾经废了老牛鼻子劲，也没有看懂网上的一些C++版本的算法实现。所以我上传上这个文件， 只希望急需的朋友们用，本人在此希望算法的原实现作者不要怪罪。
C#语言实现最短路径算法（Shortest Path）
最新发布
zy0412326的专栏
07-29 247
C#语言实现最短路径算法（Shortest Path）在C#中实现最短路径算法，可以使用经典的Dijkstra算法。这个示例中，我们创建了一个包含6个顶点的图，并添加了一些边。然后，我们从顶点0开始运行Dijkstra算法，计算并打印出从顶点0到所有其他顶点的最短路径距离。
路径规划（最短路径）算法C#实现
zhuweisky
09-29 1904
    以前空闲的时候用C#实现的路径规划算法，今日贴它出来，看大家有没有更好的实现方案。关于路径规划（最短路径）算法的背景知识，大家可以参考《C++算法－－图算法》一书。    该图算法描述的是这样的场景：图由节点和带有方向的边构成，每条边都有相应的权值，路径规划（最短路径）算法就是要找出从节点A到节点B的累积权值最小的路径。    首先，我们可以将“有向边”抽象为Edge类：  
无向图-最短路径Dijkstra(迪杰斯特拉算法)算法
csdnjquery163com的博客
11-06 4065
一、算法思路 1、采用广度优先搜索算法； 2、二维数组初始化无向图； 3、创建一个一维数组，初始化起点到其它所有节点的距离为无穷大，起点自己到自己的距离为0； 4、从起点开始找与起点相邻的其它节点的距离，将距离赋值到前面创建的一维数组，将此节点标记为已访问； 5、在一维数组中找一个没有访问过的节点，并且数值是最小的节点，将此节点作为起点重复第4步； 6、直至所有节点全部标记为已访问，程序执行结束； 二、代码 import sys class Graph: #所有节点信息 n
最短路径算法c# 最短路径算法
03-10
最短路径算法最短路径算法最短路径算法最短路径算法
C#实现最短路径Dijkstra算法
03-10
C#实现最短路径Dijkstra算法，基于VS2010，控制台应用程序，可直接运行
无向图最短路径算法c语言,无向图最短路径算法(C#)实现
weixin_32873435的博客
05-23 987
关于最短距离算法最多莫过于Dijkstra算法。能找到例子不多。书上能看到的代码大多数伪代码。而在网上看到多代码大多是C或者C++版本，而且大多没有提供完整的代码。C#的版本也找不到，故偶自己写了些代码(权值无负值).书上讲的Dijkstra算法看的不太懂，大致的意思是扩散求值的算法，即从源节点一步一步求最短路径的方法。即先找到源节点到其子节点的最短距离，然后再找源节点到其二级孙级点最短距离。如此...
最短路径算法--无向图
weixin_41563161的博客
03-01 1万+
最短路径算法 Dijkstra算法是最短路径算法中为人熟知的一种，是单起点全路径算法。该算法被称为是“贪心算法”的成功典范。 1、表示图的数据结构 邻接列表 邻接列表：在邻接列表实现中，每一个顶点会存储一个从它这里开始的边的列表。比如，如果顶点A 有一条边到B、C和D，那么A的列表中会有3条边 邻接...
C#实现最短路径算法
07-27
2. **Floyd-Warshall算法**：这是一个解决所有对最短路径问题的动态规划方法，适合处理带权的有向图或无向图。Floyd-Warshall算法通过逐步更新所有节点对之间的最短路径，最终得到完整的最短路径矩阵。C#实现时，...
C#最短路径计算
04-19
C#最短路径使用VS2017，提供源码，计算两地之间的最短距离算法
C# 图的遍历最短路径
07-09
C# 图的遍历最短路径
C#最短路径算法源码
06-19
C#最短路径算法源码
C# 最短路径 Dijkstra算法实现示例
11-28
Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。本实例实现了求最小路径的权值还能绘出最小路径的走法；
C#，图论与图算法，输出无向图“欧拉路径”的弗勒里（Fleury Algorithm）算法和源程序
03-29
C#，图论与图算法，输出无向图“欧拉路径”的弗勒里（Fleury Algorithm）算法和源程序 欧拉路径是图中每一条边只访问一次的路径。欧拉回路是在同一顶点上开始和结束的欧拉路径。 这里展示一种输出欧拉路径或回路的算法。 以下是Fleury用于打印欧拉轨迹或循环的算法（源）。 1、确保图形有0个或2个奇数顶点。 2、如果有0个奇数顶点，则从任意位置开始。如果有两个奇数顶点，请从其中一个开始。 3、沿边一次一条。如果要在桥和非桥之间进行选择，请始终选择非桥。 4、边缘用完时停止。 这个想法是，“不要过桥”，这样我们就可以回到一个顶点并遍历其余的边。
C#:实现最短路径规划算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-07 900
C#:实现最短路径规划算法(附完整源码)
最短路径—Dijkstra算法（C#）
热门推荐
潇逗
10-19 1万+
前言 ： 因为之前刚写过最小生成树算法，刚开始看到Dijkstra算法的时候，因为要求各点到源点的最短距离，会想着直接从最小生成树的也是每找到最短的距离点加进来，但是后面仔细想了下，又翻了下定义，得到 最短路径是一个图中2个点的最短距离。 最小生成树是连接所有的点的路径最短，但是不一定是任意两点的距离最小，例如： 最小生成树是：A->B->C AC距离是2+2=...
最短路径算法源码(VB)
流男@水孩
08-13 1628
本人载网站开发gis,游自编的最短路径查询程序，速度特快，3万节点，35000条路全部遍历，只需1秒。现将最短路径的思路告诉大家，希望大家在优化，并用不同语言编制，我正在学delphi,准备用delphi做成库，本例以由拓扑关系的arc/info 文件为数据源。其中a1,b1,c1是以fnode排序生成的数组，a1对应fnode,b1对应tnode,c1对应length,同样a2,b2,c2,是以
最短路径(算法第四版)(C#)
Cod_fish的博客
04-28 1090
最短路径 最短路径的性质 路径是有向的 不需要所有边都可达 负权重会使问题变得更复杂 最短路径不是唯一的 这里讨论的是单点最短路径，即找出从一个起点到所有可达顶点的最短路径构成的最短路径树。 有向加权图的数据结构 有向边的结构比无向边简单，有确定的起点和终点 有向边的结构： public class DirectEdge { private int v; //起点 ...
c# 有向无环图最短路径
07-27
对于有向无环图的最短路径问题，可以使用拓扑排序和动态规划的方法来解决。以下是一个使用 C# 编写的示例代码： ```csharp using System; using System.Collections.Generic; public class Graph { private int V; // 图中顶点的数量 private List<List<Node>> adj; // 邻接表，用于存储图的边 public Graph(int v) { V = v; adj = new List<List<Node>>(); for (int i = 0; i < V; i++) { adj.Add(new List<Node>()); } } public void AddEdge(int u, int v, int weight) { Node node = new Node(u, v, weight); adj[u].Add(node); } public void ShortestPath(int source) { int[] dist = new int[V]; for (int i = 0; i < V; i++) { dist[i] = int.MaxValue; } dist[source] = 0; // 拓扑排序 Stack<int> stack = new Stack<int>(); bool[] visited = new bool[V]; for (int i = 0; i < V; i++) { if (!visited[i]) { TopologicalSortUtil(i, visited, stack); } } // 计算最短路径 while (stack.Count > 0) { int u = stack.Pop(); if (dist[u] != int.MaxValue) { foreach (var node in adj[u]) { if (dist[u] + node.Weight < dist[node.V]) { dist[node.V] = dist[u] + node.Weight; } } } } // 输出最短路径 Console.WriteLine("顶点\t距离"); for (int i = 0; i < V; i++) { Console.WriteLine(i + "\t" + dist[i]); } } private void TopologicalSortUtil(int v, bool[] visited, Stack<int> stack) { visited[v] = true; foreach (var node in adj[v]) { if (!visited[node.V]) { TopologicalSortUtil(node.V, visited, stack); } } stack.Push(v); } private class Node { public int U { get; set; } // 边的起始顶点 public int V { get; set; } // 边的结束顶点 public int Weight { get; set; } // 边的权重 public Node(int u, int v, int weight) { U = u; V = v; Weight = weight; } } } public class Program { public static void Main(string[] args) { int V = 6; // 图中顶点的数量 Graph graph = new Graph(V); graph.AddEdge(0, 1, 2); graph.AddEdge(0, 4, 1); graph.AddEdge(1, 2, 3); graph.AddEdge(4, 2, 2); graph.AddEdge(4, 5, 4); graph.AddEdge(2, 3, 6); graph.AddEdge(5, 3, 1); int source = 0; graph.ShortestPath(source); } } ``` 在这个示例代码中，我们首先创建了一个有向无环图对象，然后使用`AddEdge`方法添加图的边。然后，我们调用`ShortestPath`方法来计算从给定源顶点到其他顶点的最短路径。最后，我们输出了所有顶点的最短路径。 请注意，这里的示例代码使用了拓扑排序和动态规划的思想来解决有向无环图的最短路径问题。这种方法适用于没有负权边的图。如果图中存在负权边，则需要使用其他算法，如 Bellman-Ford 算法或 Dijkstra 算法的变种。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值