.Net 版本 Dijkstra

最新推荐文章于 2025-01-03 09:42:25 发布

原创最新推荐文章于 2025-01-03 09:42:25 发布 · 508 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#.net #list #string #class #null

本文详细介绍了使用Dijkstra算法解决最短路径问题的方法，包括如何构建节点列表，通过迭代计算并更新最短路径，确保算法高效准确地找到从起点到终点的最短路径。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

namespace ConsoleApplication
{
    class Dijkstra
    {
        private List<Model> list = new List<Model>();

        public List<Model> Shorpath(DataTable dt)
        {
            DataRow[] drArr;
            string strNode;
            string strNodeNext;
            int iNodePoint;
            Model model;
            //判断符合增加到列表的条件
            bool blinfo;
            drArr = dt.Select("node='0'");
            foreach (DataRow dr in drArr)
            {
                blinfo = false;
                strNode = dr[0].ToString();
                strNodeNext = dr[1].ToString();
                iNodePoint = Int32.Parse(dr[2].ToString());
                model=new Model();
                model.setNode(strNode);
                model.setNodeNext(strNodeNext);
                model.setNodePoint(iNodePoint);
                model.setNodeInfo(strNode+"->"+strNodeNext);
                model.setNodeSum(iNodePoint);
                //得到子节点所有最短路径
                for (int i = 0; i < list.Count; i++)
                {
                    if (list[i].getNodeNext().Equals(model.getNodeNext()) == true)
                    {
                        blinfo = true;
                        if (list[i].getNodeSum() > model.getNodeSum())
                        {
                            list[i] = model;
                        }
                        else
                        {
                            //最短路径相同时添加路径
                            if (list[i].getNodeSum() == model.getNodeSum())
                            {
                                blinfo = false;
                            }
                        }
                        break;
                    }
                }
                if (blinfo == false)
                {
                    list.Add(model);
                }
                CalculatePath(model,dt);
            }
            return list;
        }

        //计算下一节点的最短路径，并更新结果集
        public void CalculatePath(Model model, DataTable dt)
        {
            string strNode;
            string strNodeNext;
            int iNodePoint;
            Model modelNew = null;
            DataRow[] drArr;
            bool blinfo;
            drArr = dt.Select("node='" + model.getNodeNext() + "'");
            if (drArr.Length != 0)
            {
                //得到子节点所有最短路径
                foreach (DataRow dr in drArr)
                {
                    blinfo = false;
                    strNode = dr[0].ToString();
                    strNodeNext = dr[1].ToString();
                    iNodePoint = Int32.Parse(dr[2].ToString());
                    modelNew = new Model();
                    modelNew.setNode(strNode);
                    modelNew.setNodeNext(strNodeNext);
                    modelNew.setNodePoint(iNodePoint);
                    modelNew.setNodeInfo(model.getNodeInfo() + "->" + strNodeNext);
                    modelNew.setNodeSum(model.getNodeSum()+iNodePoint);
                    //添加子节点时对已有节点判断是否重复
                    for (int i = 0; i < list.Count; i++)
                    {
                        if (list[i].getNodeNext().Equals(modelNew.getNodeNext())==true)
                        {
                            blinfo = true;
                            if (list[i].getNodeSum() > modelNew.getNodeSum())
                            {
                                list[i] = modelNew;
                            }
                            else
                            {
                                //最短路径相同时添加路径
                                if (list[i].getNodeSum() == modelNew.getNodeSum())
                                {
                                    blinfo = false;
                                }
                            }
                            break;
                        }
                    }
                    if (blinfo == false)
                    {
                        list.Add(modelNew);
                    }
                    CalculatePath(modelNew, dt);
                }

            }
        }

    }
}

Dijkstra

注明转载