Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。

其基本思想是,设置顶点集合S并不断地作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。

初始时,S中仅含有源。设u是G的某一个顶点,把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径,并用数组dist记录当前每个顶点所对应的最短特殊路径长度。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u,将u添加到S中,同时对数组dist作必要的修改。一旦S包含了所有V中顶点,dist就记录了从源到所有其它顶点之间的最短路径长度。

using System;

using System.Collections.Generic;
using System.Linq;
using System.Text; namespace ConAppDijkstra
{
    class Program
    {         private const int MaxSize = ;
        private const int INF = ;    //INF表示∞
        private const int MAXV = ;    //最大顶点个数
        //结构体的成员定义里不能直接赋值,也就是等号后的应该移除,在你后面实例化整个结构体以后,
        //再对Study_Data[n].input=new double[50] 其他成员类似。顺便说下其实用class简单得多。         struct VertexType
        {
            public string VexNo;        //顶点编号
            public string VexName;        //顶点名称
            public string otherInfo;     //顶点其他信息     
        } ;                               //顶点类型
        struct MGraph                    //图的定义
        {
            public int[,] edges;       //邻接矩阵
            public int n, e;             //顶点数,弧数
            public VertexType[] vexs; //存放顶点信息
        } ;                               //图的邻接矩阵类型         static void Ppath(int[] path, int i, int v)  //前向递归查找路径上的顶点
        {
            int k;
            k = path[i];
            if (k == v) return;    //找到了起点则返回
            Ppath(path, k, v);    //找顶点k的前一个顶点v             Console.Write("{0},", k);    //输出路径上的终点
           // Ppath(path, k, j);    //找顶点k的前一个顶点j
        }         static void Ppath(MGraph g,int[] path, int i, int v)  //前向递归查找路径上的顶点
        {
            int k;
            k = path[i];
            if (k == v) return;    //找到了起点则返回
            Ppath(path, k, v);    //找顶点k的前一个顶点v             Console.Write("{0},", g.vexs[k].VexName);    //输出路径上的终点
            // Ppath(path, k, j);    //找顶点k的前一个顶点j
        }         static void Dispath(int[] dist, int[] path, int[] s, int n, int v)
        {
            int i;
            for (i = ; i < n; i++)
            {
                if (s[i] == )
                {
                    Console.Write(" 从{0}到{1}的最短路径长度为:{2}\t路径为:", v, i, dist[i]);
                    Console.Write("{0},", v);    //输出路径上的起点
                    Ppath(path, i, v);    //输出路径上的中间点
                    Console.WriteLine("{0}", i);    //输出路径上的终点
                }
                else 
                    Console.WriteLine("从{0}到{1}不存在路径\n", v, i);
            }
        }         static void PutBothpath(MGraph g, int[] dist, int[] path, int[] s, int n, int v, int m)
        {
            int i;
            for (i = ; i < n; i++)
            {
                if (s[i] == )
                {
                    //Console.Write(" 从{0}到{1}的最短路径长度为:{2}\t路径为:", v, i, dist[i]);
                    //Console.Write("{0},", v);    //输出路径上的起点
                    //Ppath(path, i, v);    //输出路径上的中间点
                    //Console.WriteLine("{0}", i);    //输出路径上的终点
                    if (i == m && dist[i] < INF)
                    {
                        Console.Write(" 从{0}到{1}的最短路径长度为:{2}\t路径为:", g.vexs[v].VexName, g.vexs[i].VexName, dist[i]);
                        Console.Write("{0},", g.vexs[v].VexName);    //输出路径上的起点
                        //Ppath(path, i, v);    //输出路径上的中间点
                        Ppath(g, path, i, v);
                        Console.WriteLine("{0}", g.vexs[i].VexName);    //输出路径上的终点
                    }
                }
                else
                    Console.WriteLine("从{0}到{1}不存在路径\n", v, i);
            }
        }         static void Dijkstra(MGraph g, int v)
        {
            int[] dist = new int[MAXV];//从原点v到其他的各定点当前的最短路径长度
            int[] path = new int[MAXV];//path[i]表示从原点到定点i之间最短路径的前驱节点
            int[] s = new int[MAXV];   //选定的顶点的集合
            int mindis, i, j, u;
            u = ;
            for (i = ; i < g.n; i++)
            {
                dist[i] = g.edges[v, i];       //距离初始化
                s[i] = ;                        //s[]置空  0表示i不在s集合中
                if (g.edges[v, i] < INF)        //路径初始化
                    path[i] = v;
                else
                    path[i] = -;
            }
            s[v] = ;                  //源点编号v放入s中
            path[v] = ;                
            for (i = ; i < g.n; i++)                //循环直到所有顶点的最短路径都求出
            {
                mindis = INF;                    //mindis置最小长度初值
                for (j = ; j < g.n; j++)         //选取不在s中且具有最小距离的顶点u
                    if (s[j] ==  && dist[j] < mindis)
                    {
                        u = j;
                        mindis = dist[j];
                    }
                s[u] = ;                       //顶点u加入s中
                for (j = ; j < g.n; j++)         //修改不在s中的顶点的距离
                    if (s[j] == )
                        if (g.edges[u, j] < INF && dist[u] + g.edges[u, j] < dist[j])
                        {
                            dist[j] = dist[u] + g.edges[u, j];
                            path[j] = u;
                        }
            }
           Dispath(dist, path, s, g.n, v);      //输出最短路径
           //PutBothpath(g, dist, path, s, g.n, v, 3);
        }         static void initdata()
        {
            int i, j;
            MGraph g;
            g.n = ; g.e = ;
            g.edges = new int[MAXV, MAXV];
            g.vexs = new VertexType[MAXV];
            //int [,] anArray = new int [2, 4] {{1,2,3,4},{5,6,7,8}};
            int[,] a = new int[MAXV, MAXV] {
            {,  ,INF,},
            {INF,,  ,},
            {,  ,  ,},
            {INF,INF,,}
            };             for (i = ; i < g.n; i++)        //建立图的图的邻接矩阵
            {
                for (j = ; j < g.n; j++)
                {
                    g.edges[i, j] = a[i, j];///////////////////////////////////////////////
                }
            }
            Console.WriteLine("各顶点的最短路径:");
        }         static void initialVexInfo(MGraph g)
        {
            g.vexs[].VexNo = "";
            g.vexs[].VexName = "西安";             g.vexs[].VexNo = "";
            g.vexs[].VexName = "北京";             g.vexs[].VexNo = "";
            g.vexs[].VexName = "武汉";             g.vexs[].VexNo = "";
            g.vexs[].VexName = "杭州";
        }
        static void Main(string[] args)
        {
            int i, j;
            MGraph g;
            g.n = ; g.e = ;
            g.edges = new int[MAXV, MAXV];
            g.vexs = new VertexType[MAXV];             initialVexInfo(g);
            //int [,] anArray = new int [2, 4] {{1,2,3,4},{5,6,7,8}};
            int[,] a = new int[MAXV, MAXV] {
            {, ,INF,},
            {, ,  ,},
            {INF, , ,INF},
            {,,INF,}
            };             for (i = ; i < g.n; i++)        //建立图的图的邻接矩阵
            {
                for (j = ; j < g.n; j++)
                {
                    g.edges[i, j] = a[i, j];
                }
            }
            Console.WriteLine("最小生成树构成:");
            Dijkstra(g, );             Console.ReadKey();
        }
    }
}

C# 迪杰斯特拉(Dijkstra)算法的更多相关文章

  1. 迪杰斯特拉Dijkstra算法介绍

    迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径. 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止. 基本思想 通过Dijk ...

  2. JS实现最短路径之迪杰斯特拉(Dijkstra)算法

    最短路径: 对于网图来说,最短路径是指两个顶点之间经过的边上权值和最少的路径,我们称第一个顶点是源点,最后一个顶点是终点 迪杰斯特拉 ( Dijkstra) 算法是并不是一下子就求出 了 Vo 到V8 ...

  3. 最短路径算法-迪杰斯特拉(Dijkstra)算法在c#中的实现和生产应用

    迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径. 它的主要特点是以起始点为中心向外层层扩展(广度优先遍历思想),直到扩展到终点为止 贪心算法(Greedy ...

  4. 最短路径-迪杰斯特拉(dijkstra)算法及优化详解

    简介: dijkstra算法解决图论中源点到任意一点的最短路径. 算法思想: 算法特点: dijkstra算法解决赋权有向图或者无向图的单源最短路径问题,算法最终得到一个最短路径树.该算法常用于路由算 ...

  5. 最短路径 - 迪杰斯特拉(Dijkstra)算法

    对于网图来说,最短路径,是指两顶点之间经过的边上权值之和最少的路径,并且我们称路径上的第一个顶点为源点,最后一个顶点为终点.最短路径的算法主要有迪杰斯特拉(Dijkstra)算法和弗洛伊德(Floyd ...

  6. 图的最短路径---迪杰斯特拉(Dijkstra)算法浅析

    什么是最短路径 在网图和非网图中,最短路径的含义是不一样的.对于非网图没有边上的权值,所谓的最短路径,其实就是指两顶点之间经过的边数最少的路径. 对于网图,最短路径就是指两顶点之间经过的边上权值之和最 ...

  7. 单源最短路径算法:迪杰斯特拉 (Dijkstra) 算法(二)

    一.基于邻接表的Dijkstra算法 如前一篇文章所述,在 Dijkstra 的算法中,维护了两组,一组包含已经包含在最短路径树中的顶点列表,另一组包含尚未包含的顶点.使用邻接表表示,可以使用 BFS ...

  8. 单源最短路径算法:迪杰斯特拉 (Dijkstra) 算法(一)

    一.算法介绍 迪杰斯特拉算法(英语:Dijkstra's algorithm)由荷兰计算机科学家艾兹赫尔·迪杰斯特拉在1956年提出.迪杰斯特拉算法使用了广度优先搜索解决赋权有向图的单源最短路径问题. ...

  9. 迪杰斯特拉(Dijkstra)算法

    # include <stdio.h> # define MAX_VERTEXES //最大顶点数 # define INFINITY ;//代表∞ typedef struct {/* ...

随机推荐

  1. html 标签释义

    position  位置  给....定位   作用:定位 position:fixed  锁定游览器位置 如右下角弹窗 absolute  绝对定位    游览器左上角      position: ...

  2. BZOJ 2876 骑行川藏

    http://www.lydsy.com/JudgeOnline/problem.php?id=2876 拉格朗日乘数法:f'+入g'=0,f为函数的导数,g为限制条件的导数. 思路:E=Σki*si ...

  3. 用JSON 和 Google 实现全文翻译

    unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms ...

  4. SQL Server索引 - 聚集索引、非聚集索引、非聚集唯一索引 <第八篇>

    聚集索引.非聚集索引.非聚集唯一索引 我们都知道建立适当的索引能够提高查询速度,优化查询.先说明一下,无论是聚集索引还是非聚集索引都是B树结构. 聚集索引默认与主键相匹配,在设置主键时,SQL Ser ...

  5. FileMode枚举

    FileMode枚举是一个简单枚举,用于指定操作系统打开文件的方式. 枚举成员 成员值 描述 CreateNew 1 指定操作系统应创建新文件,如果文件存在则引发异常. Create 2 指定操作系统 ...

  6. OpenCV在ARM上的移植

    OpenCV在ARM上的移植 与X86 Linux类似,请参考:Linux 下编译安装OpenCV 本文在此基础上进行进一步操作. 网络上很多移植编译的方法比较老,多数针对OpenCV 1.0,而且方 ...

  7. bzoj1689 [Usaco2005 Open] Muddy roads 泥泞的路

    Description Farmer John has a problem: the dirt road from his farm to town has suffered in the recen ...

  8. android中通过自定义xml实现你需要的shape效果 xml属性配置

    在Android开发过程中,经常需要改变控件的默认样式, 那么通常会使用多个图片来解决.不过这种方式可能需要多个图片,比如一个按钮,需要点击时的式样图片,默认的式样图片,然后在写一个selector的 ...

  9. ng-cli

    angluar2 cli 是一个比较好的工具 .解决 Angular 2 环境设置是一大入门门槛,有22%的人说环境设置太过复杂.Angular CLI的诞生,正是为了解决这个问题. 1. 基本介绍 ...

  10. tomcat web项目部署方式

    1.利用MyEclipse的部署部工具部署项目,可以直接部署成文件形式,这样当启动tomcat后可以直接访问 2.利用MyEclipse部署工具部署war形式,点击发布选择tomcat时可以选择该项 ...