Krusal算法 方法2

最新推荐文章于 2022-07-10 16:26:06 发布
最新推荐文章于 2022-07-10 16:26:06 发布
阅读量735 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengzuhuang/article/details/17440425
版权
// krusal   算法根据   MST   性质。若点集合 U ~ 点集合   V   存在一点最短路径 s~t,   则最小生成树必包含   s~t   这条路。
//   利用反证法（或者剪贴法）可以证明

// krusal   算法是将整个图每个顶点看成一个集合。主要是合并集合，直到只剩一个集合为止

//   同时考虑以边为对象的   有向图



// 用最小边去找集合
#include   "stdafx.h"
#include   <iostream>
#include   <vector>
#include   <list>
#include   <algorithm>

enum
{
        Vertex_No_Connection       = -1,
        Vertex_Total_Number      = 5,
        Vertex_Max_Edge_Value      = 10000,
};


int   arrayPathScheme   [   Vertex_Total_Number ][   Vertex_Total_Number   ] =
{
     0,   10,   -1,  30,  100,
     -1,   0,   50,  -1,   -1,
     -1,  -1,   0,   -1,   10,
     -1,  -1,   20,   0,   60,
     -1,  -1,   -1,  -1,    0,
};

//   集合
struct   SVertexSet
{
        int   idSet   ;
        std :: list   < int >   listVertex ;
};

std   :: list <   SVertexSet *>   listVertexSet   ;

//   三元表
struct   SEdgeInfoNode
{
        int   nEdgeValue   ;
        int   nSourceVertex   ;
        int   nEndVertex   ;
};

//   三元表   并且递增
std   :: list <   SEdgeInfoNode *>   listEdgeInfoSet   ;

bool   SortByCmp (   SEdgeInfoNode * & pPre   ,   SEdgeInfoNode * & pNext   )
{
        if (   pPre   -> nEdgeValue   <   pNext -> nEdgeValue   )
             return   true   ;

        return   false   ;
}

void   PrintAll ()
{
        std :: list   < SEdgeInfoNode *>::   iterator   iBegin   =   listEdgeInfoSet   . begin ();
        std :: list   < SEdgeInfoNode *>::   iterator   iEnd      =   listEdgeInfoSet   . end ();
        for ( ;   iBegin   !=   iEnd ; ++   iBegin   )
     {
             SEdgeInfoNode *   pEdgeInfo   = (* iBegin );
             if (   pEdgeInfo   )
          {
                 std :: cout   << " Source->" <<   pEdgeInfo -> nSourceVertex   << " Dest->" <<   pEdgeInfo -> nEndVertex   << "   Vlaue:" <<   pEdgeInfo -> nEdgeValue   << std ::   endl ;
          }
     }
}

void   arrayInit ()
{
        //   数组预处理处理回环的值   i -> j = 50    同时   j -> i = 30.
        //   注销回环。则将 i -> j = 50   改为 i -> j = -1.
        for (   int   i   = 0;   i   <   Vertex_Total_Number   - 1; ++ i   )
     {
             for (   int   j   =   i   + 1;   j   <   Vertex_Total_Number ; ++   j   )
          {
                 if (   arrayPathScheme   [ i ][   j ] > 0 &&   arrayPathScheme   [ j ][   i ] > 0 )
              {
                      if (   arrayPathScheme   [ i ][   j ] <   arrayPathScheme   [ j ][   i ] )
                           arrayPathScheme [ j   ][ i ] = -1;
                      else
                           arrayPathScheme [ i   ][ j ] = -1;
              }
          }
     }

        //   初始化顶点集合
        listVertexSet . clear   ();
        for (   int   i   = 0;   i   <   Vertex_Total_Number   ; ++ i   )
     {
             SVertexSet *   pVertexNode   =   new   SVertexSet ;
             if ( ! pVertexNode   )
          {
                 std :: cout   << "Error 2" <<   std :: endl   ;
                 system ( "pause"   );
                 return   ;
          }

             pVertexNode -> idSet   =   i ;
             pVertexNode -> listVertex   . push_back (   i   );
          
             listVertexSet . push_back   (   pVertexNode   );
     }

        //   初始化三元表
        listEdgeInfoSet . clear   ();
        for (   int   i   = 0;   i   <   Vertex_Total_Number   ; ++ i   )
     {
             for (   int   j   = 0;   j   <   Vertex_Total_Number   ; ++ j   )
          {
                 int   nEdgeValue   =   arrayPathScheme [   i ][ j   ];
                 if ( 0 ==   nEdgeValue   || -1 ==   nEdgeValue   )
                      continue ;

                 SEdgeInfoNode *   pEdgeInfoNode   =   new   SEdgeInfoNode   ;
                 if ( ! pEdgeInfoNode   )
              {
                      std :: cout   << "Error 3" <<   std :: endl   ;
                      system ( "pause"   );
                      return   ;
              }

                 pEdgeInfoNode -> nEdgeValue        =   nEdgeValue ;
                 pEdgeInfoNode -> nSourceVertex     =   i ;
                 pEdgeInfoNode -> nEndVertex        =   j ;

                 listEdgeInfoSet . push_back   (   pEdgeInfoNode   );
          }
     }

        //PrintAll();
        listEdgeInfoSet . sort   (   SortByCmp   );
        //std::cout<<std::endl<<std::endl;
        //PrintAll();
}

bool   IsInTheSameSet (   int   nSourceIndex   ,   int   nDestIndex ,   SVertexSet   * & pSourceSet ,   SVertexSet * & pDestSet   );

int   _tmain (   int   argc   ,   _TCHAR *   argv [])
{
        arrayInit ();

        int   nSelectedEdge   = 0;     //   当边取出为   Vertex_Total_Num - 1   条时，则最小生成树构建完成
        std :: list   < SEdgeInfoNode *>::   iterator   listEdgeBegin   =   listEdgeInfoSet   . begin ();
        std :: list   < SEdgeInfoNode *>::   iterator   listEdgeEnd      =   listEdgeInfoSet   . end ();
        for ( ;   listEdgeBegin   !=   listEdgeEnd ; ++   listEdgeBegin   )
     {
             SEdgeInfoNode *   pEdgeInfoNode   = (* listEdgeBegin );
             if ( ! pEdgeInfoNode   )
          {
                 std :: cout   << "Error 4" <<   std :: endl   ;
                 system ( "pause"   );
                 return   0;
          }

             int     nSourceIndex   =   pEdgeInfoNode   -> nSourceVertex ;
             int     nDestIndex      =   pEdgeInfoNode ->   nEndVertex ;
             SVertexSet *   pSourceSet   =   NULL ;
             SVertexSet *   pDestSet      =   NULL ;
          
             bool   bIsInTwoSet   =   IsInTheSameSet (   nSourceIndex ,   nDestIndex   ,   pSourceSet ,   pDestSet   );
             if (   true   ==   bIsInTwoSet   )
          {
                 //   在同一集合内   则不处理，取下一条边
                 continue ;
          }
             else   
          {
                 //   在不同的集合内
                 //   将 pSourceSet   合并到   pDest   集合中
                 if ( ! pSourceSet   ||  ! pDestSet   )
              {
                      std :: cout   << "Error 5" <<   std :: endl   ;
                      system ( "pause"   );
                      return   0;
              }

                 std :: copy   (   pSourceSet ->   listVertex . begin   (),   pSourceSet   -> listVertex .   end (),   pDestSet   -> listVertex .   begin () );
                 std :: list   < SVertexSet *>::   iterator   ilistFind   =   listVertexSet   . begin ();
                 std :: list   < SVertexSet *>::   iterator   ilistEnd     =   listVertexSet   . end ();
                 for ( ;   ilistFind   !=   ilistEnd ; ++   ilistFind   )
              {
                      if ( (* ilistFind   ) && (* ilistFind ) ==   pDestSet   )
                           break ;
              }
                 if (   ilistFind   !=   listVertexSet .   end () )
                      listVertexSet . erase   (   ilistFind   );

                 delete   pDestSet   ;

              ++   nSelectedEdge ;
                 //   输出
                 std :: cout   << " SourceNode-> " <<   pEdgeInfoNode -> nSourceVertex   << "  DestNode->" <<   pEdgeInfoNode -> nEndVertex   << "  NodeValue:" <<   pEdgeInfoNode -> nEdgeValue   << std ::   endl ;

                 if (   Vertex_Total_Number   - 1 ==   nSelectedEdge   )
                      break ;
          }
     }

        system (   "pause"   );
        return   0;
}

bool   IsInTheSameSet (   int   nSourceIndex   ,   int   nDestIndex ,   SVertexSet   * & pSourceSet ,   SVertexSet * & pDestSet   )
{
        int   idSetSource   = -1,   idSetDest   = -1;
        std :: list   < SVertexSet *>::   iterator   ilistVertexBegin   =   listVertexSet   . begin ();
        std :: list   < SVertexSet *>::   iterator   ilistVertexEnd      =   listVertexSet   . end ();
        for ( ;   ilistVertexBegin   !=   ilistVertexEnd ; ++ ilistVertexBegin   )
     {
             SVertexSet *   pNowVertex   = (* ilistVertexBegin );
             if ( ! pNowVertex   )
          {
                 std :: cout   << "Error 6" <<   std :: endl   ;
                 system ( "pause"   );
                 return   0;
          }

             std :: list   < int >::   iterator   ilistIntBegin   =    pNowVertex   -> listVertex .   begin ();
             std :: list   < int >::   iterator   ilistIntEnd      =    pNowVertex   -> listVertex .   end ();
             for ( ;   ilistIntBegin   !=   ilistIntEnd ; ++ ilistIntBegin   )
          {
                 if ( (* ilistIntBegin   ) ==   nSourceIndex   )
              {    
                      idSetSource   =    pNowVertex   -> idSet ;
                      pSourceSet   =    pNowVertex   ;
              }

                 if ( (* ilistIntBegin   ) ==   nDestIndex   )
              {
                      idSetDest   =    pNowVertex   -> idSet ;
                      pDestSet    =    pNowVertex ;
              }
          }


             if (   idSetDest   != -1 &&   idSetSource   != -1 )
                 break ;
     }

        if (   idSetSource   != -1 &&   idSetSource   ==   idSetDest   )
             return   true   ;

        return   false   ;
}



  
郑祖煌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法方法论.xmind
08-07
算法方法论.xmind
Kruskal算法
thewebcode
04-09 112
使用并查集和贪心思想。适合稀疏图。 一直以为并查集是这样初始化的 void UFset(){ for(i=1; i&lt;=n; i++) parent[i] = i; }原来初始化为-1，更方便计算。 #include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; using n...
Krusal算法
axol63386的博客
08-07 237
边集 用个struct数组就好了 排下序 依次出来 利用并查集 合并 等操作 判断短边是否符合要求 也就是边的2个点 是否在同一棵树 取得n-1条边就OK了 也就是n个点全在一棵树 都是应用于联通图求最短 转载于:https://www.cnblogs.com/-Finch-/p/7302279.html...
Krusal算法 方法一
小飞侠
12-20 1353
// krusal 算法根据 MST 性质。若点集合U ~点集合 V 存在一点最短路径s~t, 则最小生成树必包含 s~t 这条路。 // 利用反证法（或者剪贴法）可以证明 // krusal 算法是将整个图每个顶点看成一个集合。主要是合并集合，直到只剩一个集合为止 // 这里主要以集合为考虑对象 有向图 //  用集合去找最小边 #include "
图论算法 Krusal算法
qq_43557402的博客
06-17 530
这几期针对图论算法展开讨论 图是一种重要的数据结构，而且图有很多的算法可以不光运用在表面的图上面，也可以这么说，有很多事物可以抽象成图来看。 图在生活中也有很多运用，如每个城市的高铁相连，机场，等等。范围太广，我觉得很有趣并且很重要，我在之前也介绍过其中两种算法，DFS和BFS，也粗略提过dijkstra，floyd，并查集。 今天来讲一下最小生成树。 恰好期末考试考离散，我复习了一下，加深了对k...
最小生成树 Krusal算法实现源码
04-19
java实现的kruskal最小生成树算法源码实现
Python实现LRU算法的2种方法
09-21
主要介绍了Python实现LRU算法的2种方法,本文分别给出了用OrderedDict实现、用dict+list实现两种方法,需要的朋友可以参考下
MTALAB NSGA2算法
08-08
NSGA2多目标优化遗传算法，代码亲测可运行通过，并且添加相关中文注释。
Java基于余弦方法实现的计算相似度算法示例
08-29
主要介绍了Java基于余弦方法实现的计算相似度算法,简单说明了余弦相似性的概念、原理并结合实例形式分析了java实现余弦相似性算法的相关操作技巧,需要的朋友可以参考下
Kruskal 算法介绍
实践求真知
07-10 9295
构造最小生成树还有一种算法，即 Kruskal 算法：设图 G=（V，E）是无向连通带权图，V={1,2，...n};设最小生成树 T=(V，TE)，该树的初始状态只有 n 个节点而无边的非连通图T=(V,{}),Kruskal 算法将这n 个节点看成 n 个孤立的连通分支。它首先将所有边都按权值从小到大排序，然后值要在 T 中选的边数不到 n-1,就做这样贪心选择：在边集 E 中选择权值最小的边(i,j),如果将边(i,j)加入集合 TE 中不产生回路，则将边(i,j)加入边集 TE 中，即用边(i，j)
63-Kruskal算法
网络安全
07-27 564
  Kruskal算法（也称为克鲁斯卡尔算法）也是一种用来寻找最小生成树的算法 。与Prim算法不同的是，Prim算法是逐个加入权值最小边的顶点方法，而Kruskal算法则是对每条边按权值的递增次序选择合适的边。...
并查集在kruskal算法中应用
hzylmf的专栏
11-19 2179
在无向图论问题中，经常需要得到图的最小生成树，用于解决这个问题有两个经典算法：kruskal和prim，前者用于稀疏图，后者用于稠密图。kruskal算法的核心思想是贪心，按照权值顺序，先选取权值最小的边，再选取权值次小的边，依此类推，直到所选边足够把所有的点连接起来，这时边数为节点数-1。但有个选边的前提，那就是待选边不能和已选边组成回路。至此，kruskal算法要实现的问题便成了图的连通分支判
Kruskal算法的并查集实现
HE19930303的专栏
07-19 1574
最小生成树的kruskal算法的伪代码如下 w[i]为边的权值，u[i],v[i]分别为边的端点的下标 mst为最小生成树的所有边的结合 n为顶点的个数 m为边的个数将边按权值排序w[0]<=w[1]<=……..<=w[m-1]; 初始化每个顶点属于不同的连通分量; for(i=0;i#include <iostream> using namespace std; const int NMA
经典算法之Kruskal算法
wardseptember的博客
12-13 1953
每次找出候选边中权值最小的边，就将该边并入生成树中。重复此过程直到所有边都被检测完。Kruskal算法的关键在于找出最小边和判断此最小边并入树是否形成回路。
kruskal算法(使用并查集+贪心算法)
艾克
07-31 325
# include<iostream> # include<cstring> # define inf 0x3f3f3f3f using namespace std; const int maxn=100+5; typedef struct node{ int adj; //顶点之间的权重 }node; typedef struct graph{ int vertex...
克鲁斯卡尔算法（Kruskal）详解
热门推荐
weixin_45829957的博客
08-14 3万+
应用场景-公交站问题 看一个应用场景和问题： 1)某城市新增7个站点(A, B, C, D, E, F, G) ，现在需要修路把7个站点连通 2)各个站点的距离用边线表示(权) ，比如 A – B 距离 12公里 3)问：如何修路保证各个站点都能连通，并且总的修建公路总里程最短? 克鲁斯卡尔算法介绍 1)克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 2)基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路 3)具体做法：首..
Kruskal算法并查集和最小堆实现
jzh08的专栏
08-02 1661
<br />Kruskal算法的基本思想是，将图中的节点分类，分成两个集合，分别表示成S和T其中S是不在生成树中的节点集合，T是在生成树中的节点集合。刚开始的时候，T中只有源节点一个节点。同时将图中的所有边按照权值排序。然后每次向图中添加一条权值最小的边，同时满足，这条边的一个节点在S中一个节点在T中。这样循环，直到树中有了n-1条边为止。实现的代码如下：<br /> <br /> <br /> <br />/**<br />这边使用并查集实现Kruskal算法，并没有使用最小堆，代替的使用了一个排序的方法
krusal算法求最小生成树
最新发布
07-16
Kruskal算法是一种用于求解最小生成树的贪心算法。其基本思想是将所有边按照权值从小到大排序，依次加入最小生成树中，但要保证加入的边不会形成环。具体步骤如下： 1. 将所有边按照权值从小到大排序； 2. 依次遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值