克鲁斯卡尔算法思想过程



    克鲁斯卡尔算法是计算最小生成树的一种算法。和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;  

    克鲁斯卡尔算法是计算最小生成树的一种算法。和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;  
克鲁斯卡尔算法是一种用于求解最小生成树的贪心算法。其基本思想是将所有边按照权值从小到大排序,然后依次将每条边加入到生成树中,如果加入该边不会形成环,则将该边加入到生成树中。直到生成树中有n-1条边为止,其中n为图中节点的个数。 具体实现时,可以使用并查集来判断加入一条边是否会形成环。每次加入一条边时,判断该边的两个端点是否在同一个集合中,如果在,则加入该边会形成环,不加入;如果不在,则加入该边不会形成环,可以加入。 举个例子,假设有如下图所示的无向带权图: ``` 5 a-----b | | 6 | | 4 | | c-----d 3 ``` 按照克鲁斯卡尔算法思想,首先将所有边按照权值从小到大排序,得到如下边集合: ``` {(c, d, 3), (a, b, 5), (b, d, 4), (a, c, 6)} ``` 然后依次将每条边加入到生成树中,如果加入该边不会形成环,则将该边加入到生成树中。具体过程如下: 1. 首先将权值最小的边(c, d, 3)加入到生成树中,此时生成树为{(c, d, 3)}; 2. 然后将权值为5的边(a, b, 5)加入到生成树中,此时生成树为{(c, d, 3), (a, b, 5)}; 3. 接着将权值为4的边(b, d, 4)加入到生成树中,此时生成树为{(c, d, 3), (a, b, 5), (b, d, 4)}; 4. 最后将权值为6的边(a, c, 6)加入到生成树中,此时生成树为{(c, d, 3), (a, b, 5), (b, d, 4), (a, c, 6)}。 至此,生成树中有n-1条边,算法结束。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值