最小生成树(C#)(算法第四版)

最新推荐文章于 2022-10-23 20:02:19 发布
原创 最新推荐文章于 2022-10-23 20:02:19 发布 · 641 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #图论

本文介绍了最小生成树的概念，针对加权无向图，讲解了Prim算法的延时和即时两种实现方式，以及Kruskal算法的详细过程。讨论了算法的空间和时间复杂度，并提供了C#代码实现。

最小生成树 - 加权无向图（算法第四版）

约定

这里只简单的介绍一般情况下的最小生成树问题，因此最加权图数据做了一些规定：

  1. 只考虑连通图(如果不满足会产生最小森林)
  2. 所有边的权重不同(不满足会出现多个最小生成树)

加权图数据结构

using System;
using System.Collections.Generic;
using System.Text;

namespace 图
{
    public class EdgeWeightedGraph
    {
        private List<Edge>[] _adj; //邻接表
        private int _v; //结点数
        private int _e; //边数

        /// <summary>
        /// 按文件数据生成一个加权无向图，
        /// </summary>
        /// <param name="path">图文件路径</param>
        public EdgeWeightedGraph(string path)
        {
            string line;
            System.IO.StreamReader sr = new System.IO.StreamReader(path);
            _v = Convert.ToInt32(sr.ReadLine());
            _e = 0;
            _adj = new List<Edge>[_v];
            for (int i = 0; i < _v; i++) { _adj[i] = new List<Edge>(); }
            while ((line = sr.ReadLine()) != null)
            {
                string[] str = line.Split(' ');
                int a = Convert.ToInt32(str[0]);
                int b = Convert.ToInt32(str[1]);
                float w = (float)Convert.ToDouble(str[2]);
                AddEdge(new Edge(a,b,w));
            }
        }

        public int V => _v;
        public int E => _e;

        public EdgeWeightedGraph(int v)
        {
            this._v = v;
            _adj = new List<Edge>[v];
        }

        public void AddEdge(Edge e)
        {
            int v = e.Either, w = e.Other(v);
            _adj[v].Add(e);
            _adj[w].Add(e);
            _e++;
        }

        public Edge[] Adj(int v)
        {
            return _adj[v].ToArray();
        }

        public Edge[] Edges()
        {
            List<Edge> edges = new List<Edge>();
            for (int i = 0; i < _adj.Length; i++)
            {
                for (int j = 0; j < _adj[i].Count; j++)
                {
                    edges.Add(_adj[i][j]);
                }
            }
            return edges.ToArray();
        }
    }
    //边的类
    public class Edge : IComparable
    {
        private float _weight;
        private int v; //一个结点
        private int w; //另一个结点
        public Edge(int v, int w, float weight)
        {
            this.v = v;
            this.w = w;
            this._weight = weight;
        }

        public float Weight => _weight;
        public int Either => v;

        /// <summary>
        /// 取得不同于参数的另一个结点
        /// </summary>
        public int Other(int vertex)
        {
            if (vertex == v) return w;
            else if (vertex == w) return v;
            else throw new Exception("不包含该顶点");
        }

        public int CompareTo(object? obj)
        {
            Edge other = (Edge)obj;
            if (this._weight > other.Weight) return 1;
            else if (this._weight < other.Weight) return -1;
            else return 0;
        }
    }
}

实例的加权图数据

8
4 5 .35
4 7 .37
5 7 .28
0 7 .16
1 5 .32
0 4 .38
2 3 .17
1 7 .19
0 2 .26
1 2 .36
1 3 .29
2 7 .34
6 2 .40
3 6 .52
6 0 .58
6 4 .93

切分定理

将加权图的结点分为两个部分：已经确定为最小生成树的结点和尚未加入最小生成树的结点，这连接这两部分的边中最小的一条边可以加入最小生成树。获得最小生成树的算法大都基于切分定理

常用的算法：

Prim算法
延时Prim算法

描述：从一个结点开始将与之关联的边加入一个最小堆，然后从最小堆中得到权重最小的边，将边加入用于表示最小生成树的队列，同时遍历与该边连接的另一个结点的邻接表，将边都加入最小堆，重复这个过程直到最小堆为空。
所需空间： 与E成正比，
所需时间： 与ElogE成正比(最坏情况)
API：

public LazyPrimMST(EdgeWeightedGraph g) //构造函数
private void Visit(EdgeWeightedGraph g, int v)  //添加v的未访问的邻接结点
public Edge[] Edges()  //返回最小树边的数组

详细代码：

using System;
using System.Collections.Generic;
using System.Text;
using SortFunction;

namespace 图
{
    public class LazyPrimMST
    {
        private bool[] marked;  //是否检查过该节点
        private Queue<Edge> mst; 
        private MinPQ<Edge> pq;

        public LazyPrimMST(EdgeWeightedGraph g)
        {
            marked = new bool[g.V];
            mst = new Queue<Edge>();
            pq = new MinPQ<Edge>();
            Visit(g, 0);
            while (!pq.IsEmpty())
            {
                Edge min = pq.DeleteMin();
                int v = min.Either, w = min.Other(v);
                if (marked[v] && marked[w]) continue; //跳过失效的边
                mst.Enqueue(min);
                if (!marked[v]) Visit(g, v);
                if (!marked[w]) Visit(g, w);
            }
            
        }


        /// <summary>
        /// 添加v的未访问的邻接结点
        /// </summary>
        private void Visit(EdgeWeightedGraph g, int v)
        {
            marked[v] = true;
            foreach (Edge i in g.Adj(v))
            {
                if (!marked[i.Other(v)]) pq.Insert(i);
            }
        }

        public Edge[] Edges()
        {
            return mst.ToArray();
        }
    }
}
即时Prim算法

描述：从延迟的prim算法中我们可以看到无效的边(边的两端都已经加入了最小生成树)也被加入到了最小堆里，但每次寻找边时我们需要的只是树外的点到树结点的权值最小的边，因此可以只将树外点w连接到树的边中权值最小的那个加入到最小堆(实际上是使用的索引最小堆)当中，这样可以避免在最小堆出堆时再检查边的有效性。
API： 同延时实现
所需空间： 与V成正比，
所需时间： 与ElogV成正比(最坏情况)
详细代码：

using SortFunction;
using System;

namespace 图
{
    public class Prim
    {
        private Edge[] edgeTo;
        private bool[] marked;
        private double[] distTo;
        private IndexMinPQ<double> pq; //索引最小堆，方便在找到更小的边时进行替换

        public Prim(EdgeWeightedGraph g)
        {
            edgeTo = new Edge[g.V];  //记录点连接到生成树的边
            marked = new bool[g.V]; 
            distTo = new double[g.V]; //记录连接边的权值
            pq = new IndexMinPQ<double>();
            //未赋值时设置为最大
            for (int i = 0; i < g.V; i++)
            {
                distTo[i] = Double.MaxValue;
            }
            distTo[0] = 0.0f;
            pq.Insert(0, 0.0f);
            while (!pq.IsEmpty())
            {
                Visit(g, pq.DeleteMin());
            }
        }

        private void Visit(EdgeWeightedGraph g, int v)
        {
            marked[v] = true;
            foreach (Edge e in g.Adj(v))
            {
                int w = e.Other(v);
                if (marked[w]) continue;
                if (e.Weight < distTo[w])
                {
                    edgeTo[w] = e;
                    distTo[w] = e.Weight;
                    if (pq.Contains(w)) pq.Change(w, e.Weight);
                    else pq.Insert(w, e.Weight);
                }
            }
        }
    }
}
Kruskal算法

描述： 每次将权值最小的边加入最小堆中，然后依次出堆，直到树中有V-1条边为止(完成最小生成树)，每次出堆要对结点的连通性进行检查，防止形成环
所需空间： 与E成正比
所需时间： 与ElogE成正比(最坏情况)

using SortFunction;
using System.Collections.Generic;

namespace 图
{
    public class KruskalMST
    {
        private Queue<Edge> mst;

        public KruskalMST(EdgeWeightedGraph g)
        {
            mst = new Queue<Edge>();
            MinPQ<Edge> pq = new MinPQ<Edge>();
            foreach (Edge e in g.Edges()) pq.Insert(e);
            UF uf = new UF(g.V); //uf可以进行连通性检查，本体是union-find算法

            while (!pq.IsEmpty() && mst.Count < g.V - 1)
            {
                Edge e = pq.DeleteMin();
                int v = e.Either, w = e.Other(v);
                if (uf.Connected(v, w)) continue; //如果这两个结点进通过边相连，则跳过
                uf.Union(v, w);
                mst.Enqueue(e);
            }
        }

        public Edge[] Edges => mst.ToArray();
    }
}
TensorFlow实现机器学习算法——决策树
AI天才研究院
10-02 1181
决策树（decision tree）是一种分类和回归方法，它可以用来描述对输入变量做出预测的过程。其本质是一系列条件测试用来分割数据集，每个条件测试都对应着一个节点，而分割方式对应着该节点的子节点。每一层节点都会根据自身的条件来选择将要划分的数据集，直到所有样本被分配到叶子结点上为止。在构建决策树时，我们需要确定一个评价标准，即信息增益、信息值、基尼系数或其他指标。当决策树比较复杂时，可以通过剪枝的方法来降低模型的复杂度并防止过拟合。
C#上位机AI开发进阶：用遗传算法优化机器学习模型参数的工业实践
最新发布
威哥说编程
10-30 501
将随机森林的5个参数编码为“染色体”（实数或整数数组），每个参数需符合工业场景的物理约束（避免无效值）。/// 随机森林参数染色体（基因序列）// 待优化的5个参数（基因）set;} // 树数量：[10, 200]（整数）set;} // 树深度：[5, 30]（整数，过深易过拟合）set;} // 最小分裂样本数：[2, 20]（整数）set;} // 最小叶节点样本数：[1, 10]（整数）set;} // 最大特征比例：[0.3, 1.0]（实数，如0.5表示用50%特征）
C#实现最小生成树算法
03-10
C#实现最小生成树，基于Vs2010，控制台应用程序，可直接实现
C#实现最小生成树
01-07
上窗体上有几个点，点击这些点形成连线，安最小生成树获得这些点的最小生成树
C#图形界面最小生成树
07-10
最小生成树 Access数据库操作 GDI画图 InputBoxC#实现.这是我在网上查了好多资料写的一个算最小生成树的一个窗体应用程序,综合了多方面的知识,很值得借鉴
C#图的最小生成树算法
ylq1045的专栏
06-28 585
在VisualStudio2017中，新建控制台应用程序DemoMst。新建类MinSpanningTree.cs。输入以下测试代码： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Dem...
点，线缓冲区生成算法实现（c#)
08-09
同时，为了提高效率，可以考虑使用数据结构如最小生成树或四叉树来优化相邻线段的查找和合并。 在处理点线缓冲区时，还需要注意一些细节问题，例如处理相交和重叠的缓冲区，这可能需要进行几何运算如裁剪和合并。在...
算法《第四版》笔记整理
wooeo6的博客
10-23 501
算法第四版整理
C#实现哈夫曼树构建与编码生成
第四步是生成哈夫曼编码。利用树的遍历技术，通常采用深度优先搜索（DFS）进行前序或后序遍历，从根节点出发，向左子树走标记为0，向右子树走标记为1，当到达叶子节点时，所累积的二进制序列即为对应字符的哈夫曼...
C#实现最小生成树之克鲁斯卡尔算法（Kurskal）
03-10
C#最小生成树算法之Kurskal算法,基于Vs2010，控制台窗体，可直接实现
C#实现最小生成树普里姆算法Prime
03-10
最小生成树算法，基于Vs2010，可直接运行，代码可修改
C#利用 treeview生成树
07-15
C#利用treeview从数据库中读取数据，生成树，附数据库表结构
数据结构；最小生成树；最短路径；关键路径
12-08
1、 对无向图求每个顶点的度，或对有向图求每个顶点的入度和出度（2、 完成插入顶点和边（或弧）的功能3、 完成删除顶点和边（或弧）的功能 4、 两种存储结构的转换，如果其中一种存储结构为十字链表或邻接多重表则增加 5、 输出图的深度优先遍历序列或广度优先遍历序列（6、 求图的深度优先或广度优先的生成树（或生成森林）（存储结构为孩子-兄弟链表），并对生成树进行遍历（7、 判断图的连通性，输出连通分量的个数8、 判断图中是否存在环，无向图 9、 给出顶点u和v，判断u到v是否存在路径 10、求顶点u到v的一条简单路径 11、求顶点u到v的所有简单路径 12、求顶点u到v的最短路径 13、求顶点u到其余各顶点的最短路径 14、求任两个顶点之间的最短路径 15、求最小生成树 16、对于有一个源点和一个汇点的有向网，求关键路径
C# 递归生成树_TreeView
03-09
C# 递归生成树型菜单，源码中包含了数据库，可直接可运行程序，代码有注释，易懂
技术图文：如何利用C# 实现 Prim 最小生成树算法？
老马的程序人生
06-17 3228
背景 我们上一篇图文介绍了 如何利用 C# 实现 Kruskal 最小生成树算法？，Kruskal 算法通过寻找边最优的方式来构造最小生成树，本篇图文介绍如何利用 C# 实现 Prim 最小生成树算法，Prim 算法通过寻找顶点最优的方式来构造最小生成树。 在继续介绍 Prim 算法之前，我整理了以前发布的有关数据结构与算法的图文，建个索引以方便大家的复习啊。 线性结构 如何利用“栈”解决“出轨...
最小生成树 普利姆算法代码C#实现
lizhiming930的专栏
10-17 1435
最小生成树在应用场景中经常用到，因此温习看看   最小生成树普利姆算法 http://www.cnblogs.com/biyeymyhjob/archive/2012/07/30/2615542.html C#代码实现: using System; using System.Collections.Generic; using System.Linq; using System.Text
C# 生成最小生成树——kruskal算法
wufei的专栏
04-21 2045
public  class kruskal     {         public int maxbian = 11;         public int maxdingdian = 10;         public struct edge         {
C# 最小生成树 prim算法
wufei的专栏
04-27 1279
public class prim2     {         public static int INF = 32767, maxVertexNum = 100;          public class MGraph         {            p
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值