克鲁斯卡尔算法

于 2015-12-29 23:30:54 发布
阅读量824 收藏 3
点赞数 2
分类专栏： 数据结构
本文详细介绍了克鲁斯卡尔算法的核心思想、数据结构及其实现过程，包括排序、查找和合并三大问题的解决策略。通过具体示例阐述了算法的执行流程，并深入分析了最小生成树的定义及其在实际应用中的重要意义。

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

/********************

kruskal(GRAPH* pGraph)

从graph中找出ptree 、pline、 line_number、 vexter_number 

  _kruskal(MINI_GENERATE_TREE* pTree[], int length, DIR_LINE* pLine[], int number)  

       从pline到line_number

       bubble_sort(void* array[], int length, int (*compare)(void*, void*), void(*swap)(void**, void**)) 

       pline的start、 end 是否已经都在最小生成树中

       isDoubleVectexExistInTree(MINI_GENERATE_TREE* pTree[], int length, int start, int end)  

           getVectexNumFromTree(MINI_GENERATE_TREE* pTree, int start, int end)      

       合并两个最小生成树

       mergeTwoMiniGenerateTree(MINI_GENERATE_TREE* pTree[], int length, int start, int end, int weight)

           find_tree_by_index(pTree, length, start)      

                      delete_mini_tree_from_group(MINI_GENERATE_TREE* pTree[], int length, MINI_GENERATE_TREE* pIndex)                                       insert_line_into_queue(&pFirst->pLine, line->start, line->end, line->weigh)

****************************/                                    



克鲁斯卡尔算法是计算最小生成树的一种算法。和prim算法（上，中，下）按照节点进行查找的方法不一样，克鲁斯卡尔算法是按照具体的线段进行的。现在我们假设一个图有m个节点，n条边。首先，我们需要把m个节点看成m个独立的生成树，并且把n条边按照从小到大的数据进行排列。在n条边中，我们依次取出其中的每一条边，如果发现边的两个节点分别位于两棵树上，那么把两棵树合并成为一颗树；如果树的两个节点位于同一棵树上，那么忽略这条边，继续运行。等到所有的边都遍历结束之后，如果所有的生成树可以合并成一条生成树，那么它就是我们需要寻找的最小生成树，反之则没有最小生成树。

    上面的算法可能听上去有些费解，我们可以用一个示例说明一下，

[cpp]  view plain copy
  1. /* 
  2. *          9 
  3. *    D ----------- 
  4. *  3 |           | 
  5. *    |      6    | 
  6. *    A  -------  B  
  7. *    |           | 
  8. *    |   7       | 5 
  9. *    -------C---- 
  10. **/  
    现在有这么4个点。其中 A-D 为3， A-C为7，A-B为6，B-D为9，B-C为5，下面就开始计算，我们首先默认所有的点都是单独的最小生成树，

[cpp]  view plain copy
  1. /* 
  2. *           
  3. *    D  
  4. *          
  5. *    A           B  
  6. *          
  7. *          C 
  8. **/  
    第一步，按照从小到大的顺序，我们加入最小的边A-D，

[cpp]  view plain copy
  1. /* 
  2. *           
  3. *    D  
  4. *  3 |       
  5. *    |       
  6. *    A           B  
  7. * 
  8. * 
  9. *           C 
  10. **/  
    然后，我们发现下面最小的边是B-C，
[cpp]  view plain copy
  1. /* 
  2. *           
  3. *    D  
  4. *  3 |       
  5. *    |       
  6. *    A           B  
  7. *                | 
  8. *                | 5 
  9. *           C---- 
  10. **/  
    接着，我们发现最小的边是A-B，因为点A和点B位于不同的最小生成树上面，所以继续合并，

[cpp]  view plain copy
  1. /*           
  2. *    D  
  3. *  3 |       
  4. *    |     6  
  5. *    A---------- B  
  6. *                | 
  7. *                | 5 
  8. *           C---- 
  9. **/  
    接下来，我们还会遍历A-C，B-D，但是我们发现此时边的节点都已经遍历过了，所以均忽略，最小生成树的结构就是上面的内容。

    那么最小生成树的数据结构是什么，应该怎么定义，不知道朋友们还记得否？我们曾经在prim算法中讨论过，

[cpp]  view plain copy
  1. /* 直连边 */  
  2. typedef struct _DIR_LINE  
  3. {  
  4.     int start;  
  5.     int end;  
  6.     int weight;  
  7.     struct _DIR_LINE* next;  
  8. }DIR_LINE;  
  9.   
  10. /* 最小生成树 */  
  11. typedef struct _MINI_GENERATE_TREE  
  12. {  
  13.     int node_num;  
  14.     int line_num;  
  15.     int* pNode;  
  16.     DIR_LINE* pLine;  
  17. }MINI_GENERATE_TREE;  
  18.   
  19. /* 节点边信息 */  
  20. typedef struct _LINE  
  21. {  
  22.     int end;  
  23.     int weight;  
  24.     struct _LINE* next;  
  25. }LINE;  
  26.   
  27. /*节点信息*/  
  28. typedef struct _VECTEX  
  29. {  
  30.     int start;  
  31.     int number;  
  32.     LINE* neighbor;  
  33.     struct _VECTEX* next;  
  34. }VECTEX;  
  35.   
  36. /* 图信息 */  
  37. typedef struct _GRAPH  
  38. {  
  39.     int count;  
  40.     VECTEX* head;  
  41. }GRAPH;  






【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】


    前面说到，克鲁斯卡尔的算法是按照各个line的权重依次进行添加的，那么这就涉及到一个权重的排序问题。怎么排序呢？可以采用最简单的冒泡排序算法。可是这里排序的是数据结构，怎么办呢？那就只好采用通用排序算法了。

[cpp]  view plain copy
  1. void bubble_sort(void* array[], int length, int (*compare)(void*, void*), void(*swap)(void**, void**))  
  2. {  
  3.     int outer;  
  4.     int inner;  
  5.       
  6.     for(outer = length -1; outer >0; outer --){  
  7.         for(inner = 0; inner < outer; inner ++){  
  8.             if(compare(array[inner], array[inner + 1]))  
  9.                 swap(&array[inner], &array[inner + 1]);  
  10.         }  
  11.     }  
  12.       
  13.     return;  
  14. }  
    所以，这里就要添加上属于DIR_LINE的compare和swap函数，

[cpp]  view plain copy
  1. int compare(void* data1, void* data2)  
  2. {  
  3.     DIR_LINE* line1 = (DIR_LINE*) data1;  
  4.     DIR_LINE* line2 = (DIR_LINE*) data2;  
  5.       
  6.     return (line1->weight > line2->weight) ? 1 : 0;  
  7. }  
  8.   
  9. void swap(void** data1, void** data2)  
  10. {  
  11.     DIR_LINE* median;  
  12.     DIR_LINE** line1;  
  13.     DIR_LINE** line2;  
  14.   
  15.     line1 = (DIR_LINE**) data1;  
  16.     line2 = (DIR_LINE**) data2;  
  17.   
  18.     median = *line1;  
  19.     *line1 = *line2;  
  20.     *line2 = median;  
  21. }  
    排序结束之后，我们就开始线段的插入工作，那么进行线段插入的时候，我们需要知道当前线段是不是在某一个最小生成树中已经存在了，如果是这样的话，那么这个线段就要被忽略了。所以，这中间还存在一个判断的问题，

[cpp]  view plain copy
  1. int getVectexNumFromTree(MINI_GENERATE_TREE* pTree, int start, int end)  
  2. {  
  3.     int index;  
  4.     int total;  
  5.   
  6.     total = 0;  
  7.     for(index = 0; index < pTree->node_num; index++){  
  8.         if(start == pTree->pNode[index]){  
  9.             total ++;  
  10.             continue;  
  11.         }  
  12.   
  13.         if(end == pTree->pNode[index]){  
  14.             total ++;  
  15.         }  
  16.     }  
  17.   
  18.     return total;  
  19. }  
  20.   
  21. int isDoubleVectexExistInTree(MINI_GENERATE_TREE* pTree[], int length, int start, int end)  
  22. {  
  23.     int index = 0;  
  24.     int value = 0;  
  25.     int number = 0;  
  26.   
  27.     for(index = 0; index < length; index ++){  
  28.         number = getVectexNumFromTree(pTree[index], start, end);  
  29.   
  30.         if(number > value)  
  31.             value = number;  
  32.     }  
  33.   
  34.   
  35.     return (value == 2) ? 1 : 0;  
  36. }  
    线段的判断之后，如果发现在两颗独立的最小生成树上面，那么还需要进行合并操作，删除其中一个最小生成树，把另外一个生成树的所有点和线段都要添加到没有删除的这颗最小生成树上面。当然还有一点不要忘记了，最后还要加上端口分别在两棵树上的这个线段。

[cpp]  view plain copy
  1. void  mergeTwoMiniGenerateTree(MINI_GENERATE_TREE* pTree[], int length, int start, int end, int weight)  
  2. {  
  3.     MINI_GENERATE_TREE* pFirst;  
  4.     MINI_GENERATE_TREE* pSec;  
  5.     DIR_LINE* line;  
  6.     int index;  
  7.   
  8.     /* 删除多余的最小生成树 */  
  9.     pFirst = find_tree_by_index(pTree, length, start);  
  10.     pSec = find_tree_by_index(pTree, length, end);  
  11.     delete_mini_tree_from_group(pTree, length, pSec);  
  12.   
  13.     /* 合并节点 */  
  14.     for(index = 0; index < pSec->node_num; index ++){  
  15.         pFirst->pNode[pFirst->node_num + index] = pSec->pNode[index];  
  16.     }  
  17.     pFirst->node_num += pSec->node_num;  
  18.   
  19.     /* 合并线段 */  
  20.     for(line = pSec->pLine; line; line = line->next){  
  21.         insert_line_into_queue(&pFirst->pLine, line->start, line->end, line->weight);  
  22.     }  
  23.     insert_line_into_queue(&pFirst->pLine, start, end, weight);  
  24.   
  25.     /* 函数返回 */  
  26.     return;  
  27. }  

文章总结：

    （1）本篇主要介绍了克鲁斯卡尔算法编写中需要处理的三个问题，排序、查找和合并

    （2）复杂的函数都是由简单的函数构造而成的，我们可以把算法分成几个独立的部分，各个击破

    （3）解决了这三个问题，下一篇博客就可以进行归总分析处理，逻辑上也十分清晰了







    前面在讨论克鲁斯卡尔的算法的时候，我们分析了算法的基本过程、基本数据结构和算法中需要解决的三个问题（排序、判断、合并）。今天，我们继续完成剩下部分的内容。合并函数中，我们调用了两个基本函数，find_tree_by_index和delete_mini_tree_from_group，下面给出详细的计算过程。

[cpp]  view plain copy
  1. MINI_GENERATE_TREE* find_tree_by_index(MINI_GENERATE_TREE* pTree[], int length, int point)  
  2. {  
  3.     int outer;  
  4.     int inner;  
  5.   
  6.     for(outer = 0; outer < length; outer++){  
  7.         for(inner = 0; inner < pTree[outer]->node_num; inner ++){  
  8.             if(point == pTree[outer]->pNode[inner])  
  9.                 return pTree[outer];  
  10.         }  
  11.     }  
  12.   
  13.     return NULL;  
  14. }  
  15.   
  16. void delete_mini_tree_from_group(MINI_GENERATE_TREE* pTree[], int length, MINI_GENERATE_TREE* pIndex)  
  17. {  
  18.     int index;  
  19.   
  20.     for(index = 0; index < length; index ++){  
  21.         if(pIndex == pTree[index])  
  22.             break;  
  23.     }  
  24.   
  25.     memmove(&pTree[index +1], &pTree[index], sizeof(MINI_GENERATE_TREE*) * (length -1 - index));  
  26.     return;  
  27. }  
    下面就可以开始编写克鲁斯卡尔最小生成树了，代码如下所示，

[cpp]  view plain copy
  1. MINI_GENERATE_TREE* _kruskal(MINI_GENERATE_TREE* pTree[], int length, DIR_LINE* pLine[], int number)  
  2. {  
  3.     int index;  
  4.       
  5.     if(NULL == pTree || NULL == pLine)  
  6.         return NULL;  
  7.       
  8.     for(index = 0; index < number; index ++){  
  9.           
  10.         bubble_sort((void**)pLine, number, compare, swap);  
  11.           
  12.         if(2 == isDoubleVectexExistInTree(pTree, length, pLine[index]->start, pLine[index]->end))  
  13.             continue;  
  14.           
  15.         mergeTwoMiniGenerateTree(pTree, length, pLine[index]->start, pLine[index]->end, pLine[index]->weight);  
  16.         length --;  
  17.     }  
  18.       
  19.     return (1 != length) ? NULL : pTree[0];  
  20. }  
   要进行上面的计算，我们还需要算出顶点的个数，线段的个数，所以函数还需要进一步完善和补充，

[cpp]  view plain copy
  1. MINI_GENERATE_TREE* kruskal(GRAPH* pGraph)  
  2. {  
  3.     MINI_GENERATE_TREE** pTree;  
  4.     DIR_LINE** pLine;  
  5.     int count;  
  6.     int number;  
  7.   
  8.     if(NULL == pGraph)  
  9.         return NULL;  
  10.   
  11.     count = pGraph->count;  
  12.     number = get_total_line_number(pGraph);  
  13.   
  14.     pTree = get_tree_from_graph(pGraph);  
  15.     pLine = get_line_from_graph(pGraph);  
  16.   
  17.     return _kruskal(pTree, count, pLine, number);  
  18. }  
    这样，克鲁斯卡尔算法大体上算结束了，其中get_total_line_number、get_tree_from_graph、get_line_from_graph函数都比较简单，朋友们可以自己继续完成，但是要好好测试。



总结：

    （1）代码中没有考虑内存的释放问题，需要改进和提高

    （2）部分代码可以复用prim算法中的内容，数据结构也一样

    （3）算法的编写贵在理解，只要步骤对了，再加上测试，一般问题都不大






































KruskalAlgorithm(克鲁斯卡尔算法)
colzry的博客
02-02 9254
KruskalAlgorithm介绍 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 基本思想：按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条边不构成回路 具体做法：首先构造一个只含 n 个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止 最小生成树 (Minimum Cost Spanning Tree)，简称 MST。给定一个带权的无向连通图，如何选取一棵生成树，使树上所有边上权的总和为最小，这叫最小生
C语言邻接表结构实现克鲁斯卡尔算法
12-27
C语言采用邻接表结构实现克鲁斯卡尔算法。 也可以在相应github上下载，https://github.com/Sunnk/Data-Structure，其中Kruskal文件夹中即为克鲁斯卡尔算法，可用vs打开
Kruskal算法
peizhiinfo
08-15 267
克鲁斯卡尔（Kruskal）算法（只与边相关） 算法描述：克鲁斯卡尔算法需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（eloge）。 算法过程： 1.将图各边按照权值进行排序 2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符...
克鲁斯卡尔算法.zip
07-04
克鲁斯卡尔算法是图论中的一个重要算法，用于寻找加权无向图的最小生成树。这个算法由美国数学家莫里斯·克鲁斯卡尔在1956年提出，其核心思想是按照边的权重从小到大进行排序，依次添加边到当前的生成树中，但必须...
Java语言基于无向有权图实现克鲁斯卡尔算法代码示例
08-28
Java语言基于无向有权图实现克鲁斯卡尔算法代码示例 克鲁斯卡尔算法是图论中的一种常用算法，用于寻找最小生成树。该算法的核心思想是：在带权连通图中，不断地在边集合中找到最小的边，如果该边满足得到最小生成树...
kr.rar_克鲁斯卡尔_克鲁斯卡尔算法
09-24
**克鲁斯卡尔算法详解** 克鲁斯卡尔（Kruskal's Algorithm）是一种经典的图论算法，主要用于解决无向图的最小生成树问题。在无权图或带权重的无向图中，寻找一个边的集合，使得这些边连接了所有的顶点，且集合中的...
克鲁斯卡尔matlab算法
07-20
克鲁斯卡尔算法是解决图论问题最短路径的很好的算法，永matlab进行实现
用matlab编写的kruskal算法
06-10
用matlab编写的kruskal算法，已编译
Kruskal算法的MATLAB实现
01-29
Kruskal算法的MATLAB实现，输入参数d是原图的权值矩阵；输出参数T是最小生成树的顶点组成的矩阵，每条边的两个顶点放在同一列中；a是最小生成树的总权值
克鲁斯卡尔算法实现及在控制台的应用
资源摘要信息: "kr.rar_克鲁斯卡尔_克鲁斯卡尔算法" 克鲁斯卡尔算法（Kruskal's Algorithm）是一种用于在加权图中寻找最小生成树的贪心算法。该算法由计算机科学家约瑟夫·克鲁斯卡尔（Joseph Kruskal）在1956年...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值