最小生成树算法C语言代码实例

 更新时间:2013年12月11日 16:47:43   作者:  
这篇文章主要介绍了最小生成树算法C语言代码实例,有需要的朋友可以参考一下

在贪婪算法这一章提到了最小生成树的一些算法,首先是Kruskal算法,实现如下:

MST.h

复制代码 代码如下:

#ifndef H_MST
#define H_MST

#define NODE node *
#define G graph *
#define MST edge **

/* the undirect graph start */
typedef struct _node {
 char data;
 int flag;
 struct _node *parent;
} node;

typedef struct _edge {
 node *A;
 node *B;
 int w;
} edge;

typedef struct _graph {
 node **nodelist;
 int nodeLen;
 edge **edgelist;
 int edgeLen;
} graph;

/* the undirect graph end */

int kruskal(G , edge *[]);

int makeset(NODE);

int find(NODE , NODE);

int merge(NODE , NODE);

int comp(const void *, const void *);

#endif

MST.c

复制代码 代码如下:

#include "mst.h"
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
 /* Construct the undirect connected graph */
 graph g;
 g.nodeLen = 6;
 g.edgeLen = 10;

 node node_a, node_b, node_c, node_d, node_e, node_f;
 edge edge_1, edge_2, edge_3, edge_4, edge_5, edge_6, edge_7, edge_8, edge_9, edge_10;

 node_a.data = 'a';
 node_a.flag = 0;
 node_a.parent = (node *)malloc(sizeof(node));
 node_b.data = 'b';
 node_b.flag = 0;
 node_b.parent = (node *)malloc(sizeof(node));
 node_c.data = 'c';
 node_c.flag = 0;
 node_c.parent = (node *)malloc(sizeof(node));
 node_d.data = 'd';
 node_d.flag = 0;
 node_d.parent = (node *)malloc(sizeof(node));
 node_e.data = 'e';
 node_e.flag = 0;
 node_e.parent = (node *)malloc(sizeof(node));
 node_f.data = 'f';
 node_f.flag = 0;
 node_f.parent = (node *)malloc(sizeof(node));

 edge_1.A = &node_a;
 edge_1.B = &node_b;
 edge_1.w = 5;

 edge_2.A = &node_a;
 edge_2.B = &node_c;
 edge_2.w = 6;

 edge_3.A = &node_a;
 edge_3.B = &node_d;
 edge_3.w = 4;

 edge_4.A = &node_b;
 edge_4.B = &node_c;
 edge_4.w = 1;

 edge_5.A = &node_b;
 edge_5.B = &node_d;
 edge_5.w = 2;

 edge_6.A = &node_c;
 edge_6.B = &node_d;
 edge_6.w = 2;

 edge_7.A = &node_c;
 edge_7.B = &node_e;
 edge_7.w = 5;

 edge_8.A = &node_c;
 edge_8.B = &node_f;
 edge_8.w = 3;

 edge_9.A = &node_d;
 edge_9.B = &node_f;
 edge_9.w = 4;

 edge_10.A = &node_e;
 edge_10.B = &node_f;
 edge_10.w = 4;

 node **nodelist;
 nodelist = (node **)malloc(sizeof(node *) * g.nodeLen);
 edge **edgelist;
 edgelist = (edge **)malloc(sizeof(edge *) * g.edgeLen);

 nodelist[0] = &node_a;
 nodelist[1] = &node_b;
 nodelist[2] = &node_c;
 nodelist[3] = &node_d;
 nodelist[4] = &node_e;
 nodelist[5] = &node_f;

 edgelist[0] = &edge_1;
 edgelist[1] = &edge_2;
 edgelist[2] = &edge_3;
 edgelist[3] = &edge_4;
 edgelist[4] = &edge_5;
 edgelist[5] = &edge_6;
 edgelist[6] = &edge_7;
 edgelist[7] = &edge_8;
 edgelist[8] = &edge_9;
 edgelist[9] = &edge_10;

 g.nodelist = nodelist;
 g.edgelist = edgelist;

 edge *X[g.nodeLen-1];

 int e = 0;
 while (e < g.edgeLen)
 {
  printf("%c-%c %d\n", g.edgelist[e]->A->data, g.edgelist[e]->B->data, g.edgelist[e]->w);
  e++;
 }

 printf("------------------------------------------------------\n");

 kruskal(&g, X);

 e = 0;
 while (e < (g.nodeLen-1))
 {
  printf("%c-%c %d\n", X[e]->A->data, X[e]->B->data, X[e]->w);
  e++;
 }
}

int kruskal(G g, edge *pX[])
{
 int i, j;

 /* Initially every disjoint set have one node */
 for (i = 0; i < g->nodeLen; i++)
  makeset(g->nodelist[i]);

 /* sort the edgelist */
 qsort(g->edgelist, g->edgeLen, sizeof(edge *), comp);

 int e = 0;
 while (e < g->edgeLen)
 {
  printf("%c-%c %d\n", g->edgelist[e]->A->data, g->edgelist[e]->B->data, g->edgelist[e]->w);
  e++;
 }

 printf("------------------------------------------------------\n");

 node da, db;
 da.parent = (node *)malloc(sizeof(node));
 db.parent = (node *)malloc(sizeof(node));

 for (j = 0; j < g->edgeLen; j++)
 {
  find(g->edgelist[j]->A, &da);
  find(g->edgelist[j]->B, &db);

  if (da.data != db.data)
  {
   merge(g->edgelist[j]->A, g->edgelist[j]->B);
   *pX++ = g->edgelist[j];
  }
 }
}

int makeset(NODE n)
{
 n->parent = n;
}

int find(NODE n, NODE ds)
{
 if (n->parent == n)
 {
  ds->data = n->data;
  ds->flag = 1;
  ds->parent = n->parent;
 }

 if (n->parent != n)
  find(n->parent, ds);
}

int merge(NODE da, NODE db)
{
 if (da->flag)
  db->parent = da;
 else
  da->parent = db;
}

int comp(const void *ea, const void *eb)
{
 if ((*(edge **)ea)->w > (*(edge **)eb)->w) return 1;
 else if ((*(edge **)ea)->w == (*(edge **)eb)->w ) return 0;
 else return -1;
}

在实现这个算法的时候,真正体会到了测试的重要性。程序能成功编译只是完成了一小部分,必须经过反复的测试才能发布。

相关文章

  • C++11 Unicode编码转换

    C++11 Unicode编码转换

    这篇文章主要介绍了C++11 Unicode编码转换的相关资料,帮助大家更好的理解和学习c++11,感兴趣的朋友可以了解下
    2020-08-08
  • 解析c++中的默认operator=操作的详解

    解析c++中的默认operator=操作的详解

    本篇文章是对c++中的默认operator=操作的应用进行了详细的分析介绍。需要的朋友参考下
    2013-05-05
  • 复数乘法中的结构体赋值实现代码

    复数乘法中的结构体赋值实现代码

    复数乘法中的结构体赋值实现代码。需要的朋友可以过来参考下,希望对大家有所帮助
    2013-10-10
  • C/C++中时间库函数的使用详解

    C/C++中时间库函数的使用详解

    这篇文章主要为大家详细介绍了C/C++中的时间相关知识总结,例如时间库函数的使用以及获取本地时间的不同方法,文中的示例代码讲解详细,需要的可以参考一下
    2022-11-11
  • Qt 加载 libjpeg 库出现“长跳转已经运行”错误问题解决

    Qt 加载 libjpeg 库出现“长跳转已经运行”错误问题解决

    这篇文章主要介绍了Qt 加载 libjpeg 库出现“长跳转已经运行”错误,本文给大家分享完美解决方案,需要的朋友可以参考下
    2023-04-04
  • C语言数据结构单链表接口函数全面讲解教程

    C语言数据结构单链表接口函数全面讲解教程

    这篇文章主要为大家介绍了C语言数据结构单链表所有接口函数的全面讲解教程,有需要朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2021-10-10
  • C++中继承的概念和定义

    C++中继承的概念和定义

    这篇文章主要介绍了详解C++ 中的概念和定义,帮助大家更好的理解和学习使用c++,感兴趣的朋友可以了解下,希望能给你带来帮助
    2021-08-08
  • C++ 右值引用与 const 关键字详解

    C++ 右值引用与 const 关键字详解

    C++中的const关键字的用法非常灵活,而使用const将大大改善程序的健壮性,const关键字是一种修饰符,这篇文章主要介绍了C++ 右值引用与 const 关键字,需要的朋友可以参考下
    2022-10-10
  • 详解C语言中结构体的使用

    详解C语言中结构体的使用

    结构体是一些值的集合,这些值称为成员变量,结构体的每个成员可以是不同类型的变量。本文将通过示例为大家详细讲讲C语言中结构体的使用,需要的可以参考一下
    2022-07-07
  • C++ 模拟实现list(迭代器)实现代码

    C++ 模拟实现list(迭代器)实现代码

    这篇文章主要介绍了C++ 模拟实现list(迭代器)实现代码的相关资料,需要的朋友可以参考下
    2017-05-05

最新评论