Minimum spanning tree algorithm C language code instance _c language

In the greedy algorithm this chapter mentions the minimum spanning tree some algorithms, first is the Kruskal algorithm, realizes as follows:

MST.h

Copy Code code as follows:

#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

Copy Code code as follows:

#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;
}

When you implement this algorithm, you really appreciate the importance of testing. The successful compilation of a program is only a small part of it, and must undergo repeated testing before it can be published.