无向图求最短路径迪杰斯特拉（dijkstra）算法实现

最新推荐文章于 2020-11-06 18:57:57 发布

原创最新推荐文章于 2020-11-06 18:57:57 发布 · 4.3k 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍了一个基于Dijkstra算法的实现案例，通过一个具体的图结构演示了如何寻找从起点到各个节点的最短路径。该算法利用了邻接矩阵来表示图，并通过迭代更新最短路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Dijkstra算法说明 http://ibupu.link/?id=29

namespace ConsoleApp14
{
    class Program
    {
        public static  int M = -1;
        static void Main(string[] args)
        {

            //源点
            int start = 0;
            int sVertet= start;
            int vCount = 6;

	    //图的邻接矩阵
            int[,] map = new int[6,6] {
                {0,7,9,M,M,14 }, //0点到其它点距离
                {7,0,10,15,M,M}, 
                {9,10,0,11,M,2 },
                {M,15,11,0,6,M },
                {M,M,M,6,0,9 },
                {14,M,2,M,9,0 }
            };
            //上一次最短距离 
            int[] lastMinEdge = new int[vCount];
            //当前最短距离
            int[] currentMinEdge= new int[vCount];
            //已经求得的最短距离
            int[] tColle = new int[vCount];

            //置为M ,M标记未记录的结点
            for (int i = 0; i < tColle.Length; i++)
            {
                tColle[i] = M;
            }
            //置为M ,M代表未使用
            for (int i = 0; i < lastMinEdge.Length; i++)
            {
                lastMinEdge[i] = M;
            }

            //将源点加入已记录的节点
            tColle[sVertet] = 0;
          
            while (true)
            {
                for (int i = 0; i < 6; i++)
                {
                    currentMinEdge[i] = M;
                    //未处理的顶点,
                    if (tColle[sVertet] != M && i != sVertet && tColle[i]==M)
                    {
                        //领接边距离
                        if (map[sVertet, i] != M)
                        {
                            currentMinEdge[i] = tColle[sVertet] + map[sVertet, i];
                        }
                        else

                        {
                            //非领接边 距离为M
                            currentMinEdge[i] = M;
                        }
                    }
                }
          
                //与上一轮比较
                for (int i = 0; i < 6; i++)
                {
                    if (lastMinEdge[i]!=M && tColle[i]==M)
                    {
                        if (currentMinEdge[i]!=M)
                        {
                            currentMinEdge[i] = lastMinEdge[i] < currentMinEdge[i] ? lastMinEdge[i] : currentMinEdge[i];
                        }
                        else
                        {
                            currentMinEdge[i] = lastMinEdge[i];
                        }
                    }
                  
                }


                //取得新结点最小路径
                sVertet = FindMinVertetIndex(currentMinEdge);
                tColle[sVertet] = currentMinEdge[sVertet];
                //保存当前记录
                for (int i = 0; i < currentMinEdge.Length; i++)
                {
                    if (tColle[i]==M)
                    {
                        lastMinEdge[i] = currentMinEdge[i];
                    }
                    else
                    {
                        lastMinEdge[i] = M;
                    }
                }

                Console.WriteLine("{0}到{1}的最短路径:{2}", start+1, sVertet + 1,tColle[sVertet]);


                if (tColle.Count(temp => temp == M) == 0)
                {
                    break;
                }
            }

            Console.ReadKey();
            Console.WriteLine();

        }


        private static int FindMinVertetIndex(int[] a)
        {

            int min = a.Where(temp=>temp!=M && temp>0).Min();
            int index = 0;

            for (int i = 0; i < a.Length; i++)
            {
                if (a[i]==min)
                {
                    index = i;
                }
            }
            return index;
        }
    }
}