最小生成树之Prim算法和Kruskal算法

本博客的代码的思想和图片参考：好大学慕课浙江大学陈越老师、何钦铭老师的《数据结构》

1 最小生成树的概念

最小生成树的概念：是由图生成而来的

是一棵树

1.无回路

2.如果有V个定点就有V-1条边

是生成树

1.包含图中所有的节点V

2.V-1条边都在图里面

3.边的权重和最小。

4.向生成树中添加任意一条边都构成回路。

2 算法思想：贪心算法

“贪”:每一步都要最好的。

“好”：权重最小的边

约束条件:

1.只能使用图里面的边

2.只能正好使用V-1条边

3.不能有回路

3 Prim算法—让一棵小树慢慢长大

3.1算法思想：

1.先选择一个顶点作为树的根节点，把这个根节点当成一棵树

2.选择图中距离这棵树最近但是没有被树收录的一个顶点，把他收录在树中，并且保证不构成回路

3.按照这样的方法，把所有的图的顶点一一收录进树中。

4.如果没有顶点可以收录

a.如果图中的顶点数量等于树的顶点数量-->最小生成树构造完成

b. 如果图中的顶点数量不等于树的顶点数量-->此图不连通

下面使用图片来具体描述此算法的算法思想：

 3.2Prim算法的伪代码描述

通过我们对算法的描述，我们发现Prim算法和Dijkstra算法很类似

void Prim()

{

　　MST = {s};

while (1) {

V = 未收录顶点中dist最小者;

if ( 这样的V不存在 )

break;

将V收录进MST: dist[V] = 0;

for ( V 的每个邻接点 W )

if ( dist[W]!=W未被收录 0 )

if ( E (V,W) < dist[W] ){

dist[W] = E (V,W) ;

parent[W] = V;

}

}

if ( MST中收的顶点不到|V|个 )

Error ( “生成树不存在” );

}

对于Prim算法

1.dist代表的是什么，应该如何被初始化

dist代表距离当前生成树的最小距离。和根节点直接相邻的初始化为权重，其他的初始化为正无穷。等每插入一个树节点，对dist进行更新。对于已经收录的节点，更新其dist=0

2.该算法的时间复杂度是多少

该算法时间复杂度在于如何去 ”未收录顶点中dist最小者”如果是使用暴力搜索的方法，那么时间复杂的为T=O(n^2).此种算法对于稠密图比较适用。

 

4 Kruskal 算法—将树合并成森林

4.1 算法思想

使用贪心算法，每次获取权重最小的边，但是不能让生成树构成回路。直到去到V-1条边为止。

下面还是使用一个图来说明次算法

 

 

伪代码描述

void Kruskal ( Graph G )

{

MST = { } ;

while ( MST 中不到 |V| 1 条边 && E 中还有边 ) {

从 E 中取一条权重最小的边 E (v,w) ; /* 最小堆 */

将 E (v,w) 从 E 中删除;

if ( E (V,W) 不在 MST 中构成回路) /* 并查集 */

将 E (V,W) 加入 MST;

else

彻底无视 E (V,W) ;

}

}

if ( MST 中不到 |V| 1 条边 )

Error ( “生成树不存在” );

}

如何实现“从 E 中取一条权重最小的边 E (v,w) ”---->最小堆

如何判断是否产生回路------>” 并查集”

此算法的时间复杂的为T=O(ELogE),次算法对稀疏图比较友好. 如果改图是稠密图，那么E=v^2

时间复杂度和Prim算法差不多

5 习题

下面通过一道练习题来比较Prim算法和Kruskal算法的优劣

题目的PTA链接

https://pta.patest.cn/pta/test/3512/exam/4/question/85491

题目内容：

5.1题目内容：

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

代码可以在最后的链接里面

5.2 比较Prim算法和Kruskal算法

上面的习题其实很简单，就是Prim算法和Kruskal算法的应用。很简单，只需要改一下输出即可。

Prim算法在PTA的运行结果：

Kruskal算法在PTA的运行结果：

 

5.2.1空间复杂的比较

从内存的使用情况来看，Prim算法使用的邻接矩阵来存储图，Kruskal算法使用邻接表来存储图，从图中可以看出，邻接矩阵在最N时内存由1M增长到8M，而邻接表的内存始终是在1M。由此可见在同等的数据量的情况下，邻接表比邻接矩阵更加节省内存空间。

5.2.2 时间复杂的比较

就本题的测试结果来看，Kruskal算法的时间复杂度是优于Prim算法的。本题的N最大为1000

M(edge)最大为3N,远远比不上稠密图M=N^2，只能算是稀疏图。所以在稀疏图的情况下，Kruskal算法时间复杂的度较好。和理论的证明一致。

 

 

 

Prim算法求最小生成树的权重和打印路径代码：

/*
 * prim.c
 *
 *  Created on: 2017年5月15日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*==================A adjacent matrix to describe a graph=========================================*/

/*define the data structure of the graph*/
typedef struct gMNode *ptrTogMNode;
typedef struct gMNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    weightType g[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*define the adjacent matrix weight of graph*/
    dataType data[MAX_VERTEX_NUM]; /*define the dataType array to store the value of vertex*/
};
typedef ptrTogMNode adjacentMatrixGraph; /*a graph show by adjacent matrix*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentMatrixGraph createMGraph(int vertexNum) {
    vertex v, w;
    adjacentMatrixGraph graph;
    graph = (adjacentMatrixGraph) malloc(sizeof(struct gMNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent matrix*/
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = 0; w < graph->vertex_number; w++) {
            graph->g[v][w] = INFINITY;
        }
    }

    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent matrix [n][m]=[m][n]=edge's weight,else we only set
 the adjacent matrix [n][m]=edge's weight
 */
void inserEdgeToMatrix(adjacentMatrixGraph graph, edge e, int isOriented) {
    graph->g[e->v1][e->v2] = e->weight;
    if (!isOriented) {
        graph->g[e->v2][e->v1] = e->weight;
    }
}

/*
 construct a graph according user's input

 @return a graph has been filled good
 */
adjacentMatrixGraph buildMGraph(int isOrdered) {
    adjacentMatrixGraph graph;
    edge e;
    vertex i;
    int vertex_num;
    scanf("%d", &vertex_num);
    graph = createMGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            inserEdgeToMatrix(graph, e, isOrdered);
        }
    }
    return graph;

}

/*==================A adjacent link to describe a graph=========================================*/
/*define the data structure adjacent table node*/
typedef struct adjNode *ptrToAdjNode;
typedef struct adjNode {
    vertex adjVerx; /*the index of the vertex*/
    weightType weight; /*the value of the weight*/
    ptrToAdjNode next; /*the point to point the next node*/
};

/*define the data structure of the adjacent head*/
typedef struct vNode *ptrToVNode;
typedef struct vNode {
    ptrToAdjNode head; /*the point to point the adjacent table node*/
    dataType data; /*the space to store the name of the vertex,but some time the vertex has no names*/
} adjList[MAX_VERTEX_NUM];

/*define the data structure of graph*/
typedef struct gLNode *ptrTogLNode;
typedef struct gLNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    adjList g; /*adjacent table*/
};
typedef ptrTogLNode adjacentTableGraph; /*a graph show by adjacent table*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentTableGraph createLGraph(int vertexNum) {
    adjacentTableGraph graph;

    vertex v;
    graph = (adjacentTableGraph) malloc(sizeof(struct gLNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent table*/
    for (v = 0; v < graph->vertex_number; v++) {
        graph->g[v].head = NULL;
    }
    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 The e->v1 and e->v2 are the vertexs' indexs in the adjacent table
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent table graph[v1]->head=v2 and set graph[v1].head=v2
 otherwise we only set graph[v1].head=v2
 */
void insertEdgeToLink(adjacentTableGraph graph, edge e, int isOriented) {
    /*build node<v1,v2>*/
    ptrToAdjNode newNode;
    newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
    newNode->adjVerx = e->v2;
    newNode->weight = e->weight;
    newNode->next = graph->g[e->v1].head;
    graph->g[e->v1].head = newNode;
    /*if the graph is directed graph*/
    if (!isOriented) {
        newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
        newNode->adjVerx = e->v1;
        newNode->weight = e->weight;
        newNode->next = graph->g[e->v2].head;
        graph->g[e->v2].head = newNode;
    }
}

/*
 build a graph stored by adjacent table
 */
adjacentTableGraph buildLGraph() {
    adjacentTableGraph graph;
    edge e;
    vertex i;
    int vertex_num;

    scanf("%d", &vertex_num);
    graph = createLGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            insertEdgeToLink(graph, e, 0);
        }
    }

    return graph;
}

/*
 * Find the minimal node closest to created tree
 */
vertex findMinDist(adjacentMatrixGraph graph, weightType dist[]) {
    vertex minV, v;
    weightType minDist = INFINITY;
    for (v = 0; v < graph->vertex_number; v++) {
        if (dist[v] != 0 && dist[v] < minDist) {
            minDist = dist[v];
            minV = v;
        }
    }
    if (minDist < INFINITY) {
        return minV;
    } else {
        return ERROR;
    }
}

/*
 * Prim algorithms,we will store the minimal created tree with a adjacent
 * list table and return the minimal weight
 * @param mGraph The graph showed by adjacent matrix is to store graph
 * @param lGraph The graph showed by adjacent list is to store the minimal created tree
 * @return The weight of the minimal created tree if the graph is connected, otherwise return
 * <code>ERROR</code>
 */
int prim(adjacentMatrixGraph mGraph, adjacentTableGraph lGraph) {

    weightType dist[mGraph->vertex_number], totalWeight;
    vertex parent[mGraph->vertex_number], v, w;
    int vCounter;
    edge e;

    /*
     * Initialize dist and parent,default the start point is 0 index
     */
    for (v = 0; v < mGraph->vertex_number; v++) {
        dist[v] = mGraph->g[0][v];
        parent[v] = 0;
    }

    /*
     * Initialize weight and vertex counter
     */
    totalWeight = 0;
    vCounter = 0;
    /*
     * Initialize a edge
     */
    e = (edge) malloc(sizeof(struct eNode));

    /*
     * Initialize dist[0] as the root of tree and set parent[0] to -1
     */
    dist[0] = 0;
    vCounter++;
    parent[0] = -1;
    /*
     * Execute Prim algorithms
     */
    while (1) {
        v = findMinDist(mGraph, dist);
        if (v == ERROR) {
            break;
        }

        /*
         * Put <v,parent[v]> to tree
         */
        e->v1 = parent[v];
        e->v2 = v;
        e->weight = dist[v];
        insertEdgeToLink(lGraph, e, 1);
        totalWeight += dist[v];
        vCounter++;
        dist[v] = 0;

        /*
         * Update the v adjacent vertex distance with minimal tree
         */
        for (w = 0; w < mGraph->vertex_number; w++) {
            /*
             * If w is v adjacent vetex and not be added to minimal tree
             */
            if (dist[w] != 0 && mGraph->g[v][w] < INFINITY) {
                /*
                 * Update the distance to minimal created tree
                 */
                if (mGraph->g[v][w] < dist[w]) {
                    dist[w] = mGraph->g[v][w];
                    parent[w] = v;
                }
            }
        }
    }
    if (vCounter < mGraph->vertex_number) {
        return ERROR;
    } else {
        return totalWeight;
    }
}

/*========Use DFS to print the result of the minimal created tree==========*/
/*
 * A method to access graph
 */
void visit(adjacentTableGraph graph, vertex v) {
    printf("%d ", v);
}

/*
 Depth first search a graph
 @param graph The graph need to search
 @param startPoint The fisrt point we start search the graph
 @paran int *visited The array we use to tag the vertex we has accessed.
 */
void DFS(adjacentTableGraph graph, vertex startPoint, int *visited) {
    ptrToAdjNode p;
    visit(graph, startPoint);
    p = graph->g[3].head;
    visited[startPoint] = 1;
    for (p = graph->g[startPoint].head; p; p = p->next) {
        if (visited[p->adjVerx] == 0) {
            DFS(graph, p->adjVerx, visited);
        }
    }
}

/*
 * Initialize a visited array that make them all to zero
 */
void initVisited(int length, int *visited) {
    int i;
    for (i = 0; i < length; i++) {
        visited[i] = 0;
    }
}

int main() {
    adjacentTableGraph lGraph;
    adjacentMatrixGraph mGraph = buildMGraph(0);
    vertex visited[mGraph->vertex_number];
    lGraph = createLGraph(mGraph->vertex_number);
    weightType totalWeigt = prim(mGraph, lGraph);
    printf("totalWeigh:%d\n", totalWeigt);
    initVisited(mGraph->vertex_number, visited);
    DFS(lGraph, 0, visited);
    return 0;
}

测试数据和运行结果：

7 12
1 2 2
1 4 1
2 5 10
2 4 3
3 1 4
3 6 5
4 3 2
4 6 8
4 7 4
4 5 7
5 7 6
7 6 1

Test result:
totalWeigh:16
0 1 3 6 4 5 2 

 

Kruskal算法求最小生成树的权重和打印路径代码：

/*
 * kruskal.c
 *
 *  Created on: 2017年5月15日
 *      Author: ygh
 */

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

#define MAX_VERTEX_NUM 10001 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*==================A adjacent link to describe a graph=========================================*/
/*define the data structure adjacent table node*/
typedef struct adjNode *ptrToAdjNode;
typedef struct adjNode {
    vertex adjVerx; /*the index of the vertex*/
    weightType weight; /*the value of the weight*/
    ptrToAdjNode next; /*the point to point the next node*/
};

/*define the data structure of the adjacent head*/
typedef struct vNode *ptrToVNode;
typedef struct vNode {
    ptrToAdjNode head; /*the point to point the adjacent table node*/
    dataType data; /*the space to store the name of the vertex,but some time the vertex has no names*/
} adjList[MAX_VERTEX_NUM];

/*define the data structure of graph*/
typedef struct gLNode *ptrTogLNode;
typedef struct gLNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    adjList g; /*adjacent table*/
};
typedef ptrTogLNode adjacentTableGraph; /*a graph show by adjacent table*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentTableGraph createLGraph(int vertexNum) {
    adjacentTableGraph graph;

    vertex v;
    graph = (adjacentTableGraph) malloc(sizeof(struct gLNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent table*/
    for (v = 0; v < graph->vertex_number; v++) {
        graph->g[v].head = NULL;
    }
    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 The e->v1 and e->v2 are the vertexs' indexs in the adjacent table
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent table graph[v1]->head=v2 and set graph[v1].head=v2
 otherwise we only set graph[v1].head=v2
 */
void insertEdgeToLink(adjacentTableGraph graph, edge e, int isOriented) {
    /*build node<v1,v2>*/
    ptrToAdjNode newNode;
    newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
    newNode->adjVerx = e->v2;
    newNode->weight = e->weight;
    newNode->next = graph->g[e->v1].head;
    graph->g[e->v1].head = newNode;
    /*if the graph is directed graph*/
    if (!isOriented) {
        newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
        newNode->adjVerx = e->v1;
        newNode->weight = e->weight;
        newNode->next = graph->g[e->v2].head;
        graph->g[e->v2].head = newNode;
    }
}

/*
 build a graph stored by adjacent table
 */
adjacentTableGraph buildLGraph(int isOrdered) {
    adjacentTableGraph graph;
    edge e;
    vertex i;
    int vertex_num;

    scanf("%d", &vertex_num);
    graph = createLGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            insertEdgeToLink(graph, e, isOrdered);
        }
    }

    return graph;
}

/*----------------------define collection and some operator of graph's nodes-----------------------------*/

/*
 * The element of collection
 */
typedef vertex elementType;

/*
 * The index of root element,we use it as the collection name
 */
typedef vertex setName;

/*
 * A array to store the collection,we set the
 * first index is 0
 */
typedef elementType setType[MAX_VERTEX_NUM];

/*
 * Initialize collection
 * @param A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param n The length of the collection
 */
void initializeVSet(setType s, int n) {
    elementType x;
    for (x = 0; x < n; x++) {
        s[x] = -1;
    }
}

/*
 * Union two collections which is showed by root element.We will union smaller collection
 * to greater collection and we will update the quantity for greater collection
 * @param s A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param root1 The root element of the first collection
 * @param root2 The root element of the second collection
 */
void unionCollection(setType s, setName root1, setName root2) {
    /*
     * If root2's quantity greater than root1
     */
    if (s[root2] < s[root1]) {
        s[root2] += s[root1];
        s[root1] = root2;
    } else {
        s[root1] += s[root2];
        s[root2] = root1;
    }
}

/*
 * Find the element in which collection and use the root element
 * to represent this collection and return it.In this method,we will compress path
 * @param s A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param x The element we find which collection it in.
 */
setName find(setType s, elementType x) {
    if (s[x] < 0) {
        return x;
    } else {
        /*
         *compress path
         */
        return s[x] = find(s, s[x]);
    }
}

/*
 * Check v1 and v1 whether is belong to a same collection. If not union these
 * two collection,otherwise do nothing.
 * @param vSet A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param v1 The index of node in the graph,also the element is the collection.
 * @param v2 The index of node in the graph,also the element is the collection.
 * @return If the two element is belong same collection,union them and return 1
 * else do nothing and return 0;
 */
int checkCircle(setType vSet, vertex v1, vertex v2) {
    setName root1 = find(vSet, v1);
    setName root2 = find(vSet, v2);
    if (root1 == root2) {
        return 0;
    } else {
        unionCollection(vSet, root1, root2);
        return 1;
    }
}

/*-------------define the minimal heap of edge-------------------*/

/*
 * Update the tree whose root element index is p into minimal heap,we use the edgs's
 * weight as the to construct the minimal heap.
 *
 * @param eset A array of edge to store the heap,because the edge is point variable
 * So the eSet is a edge type array,you can compare it with <code>int* arr</code>
 * @param The index of the root element.
 * @param n The length of the heap,the max index is n-1 in this case. And
 * this heap index is start from zero.
 */
void percDowm(edge eSet, int p, int n) {
    int parent, child;
    struct eNode x;

    x = eSet[p];
    for (parent = p; (parent * 2 + 1) < n; parent = child) {
        /*
         * Because the first index if from zero,so the left child
         * is parent*2+1
         */
        child = parent * 2 + 1;
        /*
         * Find smaller weigh between the left child and right child
         */
        if ((child != n - 1) && eSet[child].weight > eSet[child + 1].weight) {
            child++;
        }
        if (x.weight <= eSet[child].weight) {
            break;
        } else {
            eSet[parent] = eSet[child];
        }
    }
    eSet[parent] = x;
}

/*
 * Initialize eSet heap and update it to be the minimal heap
 * @param graph A graph which is stored by adjacent list
 * @param eSet A array of the edge as the minimal heap
 */
void initializeESet(adjacentTableGraph graph, edge eSet) {
    vertex v;
    ptrToAdjNode w;
    int counter = 0;
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = graph->g[v].head; w; w = w->next) {
            /*
             * expect for put same edge to it,we only
             * put <v1,v2> to it.
             */
            if (v < w->adjVerx) {
                eSet[counter].v1 = v;
                eSet[counter].v2 = w->adjVerx;
                eSet[counter].weight = w->weight;
                counter++;
            }

        }
    }
    /*
     * Initialize the minimal heap
     */
    for (counter = graph->edge_nunber / 2; counter >= 0; counter--) {
        percDowm(eSet, counter, graph->edge_nunber);
    }
}

/*
 * Get minimal edge from the minimal weight heap
 * @param eset A array of edge to store the heap,because the edge is point variable
 * So the eSet is a edge type array,you can compare it with <code>int* arr</code>
 * @param The current size of the minimal heap
 * @return The index of the minimal edge in this heap(array)
 */
int getEdge(edge eSet, int currentSize) {
    if (currentSize == 0) {
        return currentSize - 1;
    }
    struct eNode temp = eSet[currentSize - 1];
    eSet[currentSize - 1] = eSet[0];
    eSet[0] = temp;
    percDowm(eSet, 0, currentSize - 1);
    return currentSize - 1;
}

/*
 * Implement the kruskal algorithms to find the minimal created tree
 * Algorithms thought:we choose the minimal edge from graph but don't
 * construct a circle each time. Until we choose the V-1 edges. The V
 * is equal with the quantity of the graph's vertex
 * In this program,we will use a counter to record the quantity of edges
 * At last of this method,if we check the quantity of the edge is less than
 * V-1, it indicates the graph is not collected,so -1 will be return,otherwise we will return
 * the minimal created tree total weight.
 * @param graph A graph which is stored by adjacent list
 * @param mst A A graph which is stored by adjacent list to store the minimal created tree
 * @return If the graph is collected,the weight of the minimal created tree
 * will be return, otherwise return -1
 */
int kruskal(adjacentTableGraph graph, adjacentTableGraph mst) {
    /*
     * totalWeight is to record the total weight
     * of the minimal created tree
     */
    weightType totalWeight;
    /*
     * eCounter is to record the quantity of edges which has been
     * insert the <code>mst<code>
     *
     * nextEdge is to record the next minimal edge in the minimal heap
     */
    int eCounter, nextEdge;

    /*
     *A set of the vertex to store the vertex and implement
     *some operation such as union find and so on
     */
    setType vSet;

    /*
     * A array of edge to as the minimal heap to store the egdes
     */
    edge eSet;

    /*
     * Initialize some variables
     */
    initializeVSet(vSet, graph->vertex_number);
    eSet = (edge) malloc((sizeof(struct eNode)) * (graph->edge_nunber));
    initializeESet(graph, eSet);
//    mst = createLGraph(graph->vertex_number);
    totalWeight = 0;
    eCounter = 0;
    nextEdge = graph->edge_nunber;
    while (eCounter < graph->vertex_number - 1) {
        nextEdge = getEdge(eSet, nextEdge);
        if (nextEdge < 0) {
            break;
        }
        /*
         * Check whether a circle between two vertex
         */
        if (checkCircle(vSet, eSet[nextEdge].v1, eSet[nextEdge].v2)) {
            insertEdgeToLink(mst, eSet + nextEdge, 0);
            totalWeight += eSet[nextEdge].weight;
            eCounter++;
        }
    }
    if (eCounter < graph->vertex_number - 1) {
        totalWeight = -1;
    }
    return totalWeight;
}

/*========Use DFS to print the result of the minimal created tree==========*/
/*
 * A method to access graph
 */
void visit(adjacentTableGraph graph, vertex v) {
    printf("%d ", v);
}

/*
 Depth first search a graph
 @param graph The graph need to search
 @param startPoint The fisrt point we start search the graph
 @paran int *visited The array we use to tag the vertex we has accessed.
 */
void DFS(adjacentTableGraph graph, vertex startPoint, int *visited) {
    ptrToAdjNode p;
    visit(graph, startPoint);
    p = graph->g[3].head;
    visited[startPoint] = 1;
    for (p = graph->g[startPoint].head; p; p = p->next) {
        if (visited[p->adjVerx] == 0) {
            DFS(graph, p->adjVerx, visited);
        }
    }
}

/*
 * Initialize a visited array that make them all to zero
 */
void initVisited(int length, int *visited) {
    int i;
    for (i = 0; i < length; i++) {
        visited[i] = 0;
    }
}

int main() {
    adjacentTableGraph graph = buildLGraph(0);
    adjacentTableGraph mst = createLGraph(graph->vertex_number);
    vertex visited[graph->vertex_number];
    weightType totalWeight = kruskal(graph, mst);
    printf("totalWeight:%d\n", totalWeight);
    initVisited(graph->vertex_number, visited);
    DFS(mst, 0, visited);
    return 0;
}

测试数据和运行结果

7 12
1 2 2
1 4 1
2 5 10
2 4 3
3 1 4
3 6 5
4 3 2
4 6 8
4 7 4
4 5 7
5 7 6
7 6 1

Test result:
totalWeigh:16
0 1 3 6 4 5 2 

 

上面村村通习题的Prim代码

/*
 * path.c
 *
 *  Created on: 2017年5月15日
 *      Author: ygh
 */
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 10001 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*==================A adjacent matrix to describe a graph=========================================*/

/*define the data structure of the graph*/
typedef struct gMNode *ptrTogMNode;
typedef struct gMNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    weightType g[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*define the adjacent matrix weight of graph*/
    dataType data[MAX_VERTEX_NUM]; /*define the dataType array to store the value of vertex*/
};
typedef ptrTogMNode adjacentMatrixGraph; /*a graph show by adjacent matrix*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentMatrixGraph createMGraph(int vertexNum) {
    vertex v, w;
    adjacentMatrixGraph graph;
    graph = (adjacentMatrixGraph) malloc(sizeof(struct gMNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent matrix*/
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = 0; w < graph->vertex_number; w++) {
            graph->g[v][w] = INFINITY;
        }
    }

    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent matrix [n][m]=[m][n]=edge's weight,else we only set
 the adjacent matrix [n][m]=edge's weight
 */
void inserEdgeToMatrix(adjacentMatrixGraph graph, edge e, int isOriented) {
    graph->g[e->v1][e->v2] = e->weight;
    if (!isOriented) {
        graph->g[e->v2][e->v1] = e->weight;
    }
}

/*
 construct a graph according user's input

 @return a graph has been filled good
 */
adjacentMatrixGraph buildMGraph(int isOrdered) {
    adjacentMatrixGraph graph;
    edge e;
    vertex i;
    int vertex_num;
    scanf("%d", &vertex_num);
    graph = createMGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            inserEdgeToMatrix(graph, e, isOrdered);
        }
    }
    return graph;

}

/*==================A adjacent link to describe a graph=========================================*/
/*define the data structure adjacent table node*/
typedef struct adjNode *ptrToAdjNode;
typedef struct adjNode {
    vertex adjVerx; /*the index of the vertex*/
    weightType weight; /*the value of the weight*/
    ptrToAdjNode next; /*the point to point the next node*/
};

/*define the data structure of the adjacent head*/
typedef struct vNode *ptrToVNode;
typedef struct vNode {
    ptrToAdjNode head; /*the point to point the adjacent table node*/
    dataType data; /*the space to store the name of the vertex,but some time the vertex has no names*/
} adjList[MAX_VERTEX_NUM];

/*define the data structure of graph*/
typedef struct gLNode *ptrTogLNode;
typedef struct gLNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    adjList g; /*adjacent table*/
};
typedef ptrTogLNode adjacentTableGraph; /*a graph show by adjacent table*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentTableGraph createLGraph(int vertexNum) {
    adjacentTableGraph graph;

    vertex v;
    graph = (adjacentTableGraph) malloc(sizeof(struct gLNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent table*/
    for (v = 0; v < graph->vertex_number; v++) {
        graph->g[v].head = NULL;
    }
    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 The e->v1 and e->v2 are the vertexs' indexs in the adjacent table
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent table graph[v1]->head=v2 and set graph[v1].head=v2
 otherwise we only set graph[v1].head=v2
 */
void insertEdgeToLink(adjacentTableGraph graph, edge e, int isOriented) {
    /*build node<v1,v2>*/
    ptrToAdjNode newNode;
    newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
    newNode->adjVerx = e->v2;
    newNode->weight = e->weight;
    newNode->next = graph->g[e->v1].head;
    graph->g[e->v1].head = newNode;
    /*if the graph is directed graph*/
    if (!isOriented) {
        newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
        newNode->adjVerx = e->v1;
        newNode->weight = e->weight;
        newNode->next = graph->g[e->v2].head;
        graph->g[e->v2].head = newNode;
    }
}

/*
 build a graph stored by adjacent table
 */
adjacentTableGraph buildLGraph() {
    adjacentTableGraph graph;
    edge e;
    vertex i;
    int vertex_num;

    scanf("%d", &vertex_num);
    graph = createLGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            insertEdgeToLink(graph, e, 0);
        }
    }

    return graph;
}

/*
 * Find the minimal node closest to created tree
 */
vertex findMinDist(adjacentMatrixGraph graph, weightType dist[]) {
    vertex minV, v;
    weightType minDist = INFINITY;
    for (v = 0; v < graph->vertex_number; v++) {
        if (dist[v] != 0 && dist[v] < minDist) {
            minDist = dist[v];
            minV = v;
        }
    }
    if (minDist < INFINITY) {
        return minV;
    } else {
        return ERROR;
    }
}

/*
 * Prim algorithms,we will store the minimal created tree with a adjacnet
 * list table and return the minimal weight
 * @param mGraph The graph showed by adjacent matrix is to store graph
 * @param lGraph The graph showed by adjacent list is to store the minimal created tree
 * @return The weight of the minimal created tree if the graph is connected, otherwise return
 * <code>ERROR</code>
 */
int prim(adjacentMatrixGraph mGraph, adjacentTableGraph lGraph) {

    weightType dist[mGraph->vertex_number], totalWeight;
    vertex parent[mGraph->vertex_number], v, w;
    int vCounter;
    edge e;

    /*
     * Initialize dist and parent,default the start point is 0 index
     */
    for (v = 0; v < mGraph->vertex_number; v++) {
        dist[v] = mGraph->g[0][v];
        parent[v] = 0;
    }

    /*
     * Initialize weight and vertex counter
     */
    totalWeight = 0;
    vCounter = 0;
    /*
     * Initialize a edge
     */
    e = (edge) malloc(sizeof(struct eNode));

    /*
     * Initialize dist[0] as the root of tree and set parent[0] to -1
     */
    dist[0] = 0;
    vCounter++;
    parent[0] = -1;
    /*
     * Execute Prim algorithms
     */
    while (1) {
        v = findMinDist(mGraph, dist);
        if (v == ERROR) {
            break;
        }

        /*
         * Put <v,parent[v]> to tree
         */
        e->v1 = parent[v];
        e->v2 = v;
        e->weight = dist[v];
        insertEdgeToLink(lGraph, e, 1);
        totalWeight += dist[v];
        vCounter++;
        dist[v] = 0;

        /*
         * Update the v adjacent vertex distance with minimal tree
         */
        for (w = 0; w < mGraph->vertex_number; w++) {
            /*
             * If w is v adjacent vetex and not be added to minimal tree
             */
            if (dist[w] != 0 && mGraph->g[v][w] < INFINITY) {
                /*
                 * Update the distance to minimal created tree
                 */
                if (mGraph->g[v][w] < dist[w]) {
                    dist[w] = mGraph->g[v][w];
                    parent[w] = v;
                }
            }
        }
    }
    if (vCounter < mGraph->vertex_number) {
        return ERROR;
    } else {
        return totalWeight;
    }
}

/*========Use DFS to print the result of the minimal created tree==========*/
/*
 * A method to access graph
 */
void visit(adjacentTableGraph graph, vertex v) {
    printf("%d ", v);
}

/*
 Depth first search a graph
 @param graph The graph need to search
 @param startPoint The fisrt point we start search the graph
 @paran int *visited The array we use to tag the vertex we has accessed.
 */
void DFS(adjacentTableGraph graph, vertex startPoint, int *visited) {
    ptrToAdjNode p;
    visit(graph, startPoint);
    p = graph->g[3].head;
    visited[startPoint] = 1;
    for (p = graph->g[startPoint].head; p; p = p->next) {
        if (visited[p->adjVerx] == 0) {
            DFS(graph, p->adjVerx, visited);
        }
    }
}

/*
 * Initialize a visited array that make them all to zero
 */
void initVisited(int length, int *visited) {
    int i;
    for (i = 0; i < length; i++) {
        visited[i] = 0;
    }
}

int main() {
    adjacentTableGraph lGraph;
    adjacentMatrixGraph mGraph = buildMGraph(0);
    vertex visited[mGraph->vertex_number];
    lGraph = createLGraph(mGraph->vertex_number);
    weightType totalWeigt = prim(mGraph, lGraph);
    printf("%d\n", totalWeigt);
    return 0;
}

上面村村通习题的Kruskal代码

/*
 * kruskal.c
 *
 *  Created on: 2017年5月15日
 *      Author: ygh
 */

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

#define MAX_VERTEX_NUM 10001 /*define the max number of the vertex*/
#define INFINITY 65535     /*define double byte no negitive integer max number is 65535*/
#define ERROR -1

typedef int vertex; /*define the data type of the vertex*/
typedef int weightType; /*define the data type of the weight*/
typedef char dataType; /*define the data type of the vertex value*/

/*define the data structure of the Edge*/
typedef struct eNode *ptrToENode;
typedef struct eNode {
    vertex v1, v2; /*two vertex between the edge <v1,v2>*/
    weightType weight; /*the value of the edge's weight */
};
typedef ptrToENode edge;

/*==================A adjacent link to describe a graph=========================================*/
/*define the data structure adjacent table node*/
typedef struct adjNode *ptrToAdjNode;
typedef struct adjNode {
    vertex adjVerx; /*the index of the vertex*/
    weightType weight; /*the value of the weight*/
    ptrToAdjNode next; /*the point to point the next node*/
};

/*define the data structure of the adjacent head*/
typedef struct vNode *ptrToVNode;
typedef struct vNode {
    ptrToAdjNode head; /*the point to point the adjacent table node*/
    dataType data; /*the space to store the name of the vertex,but some time the vertex has no names*/
} adjList[MAX_VERTEX_NUM];

/*define the data structure of graph*/
typedef struct gLNode *ptrTogLNode;
typedef struct gLNode {
    int vertex_number; /*the number of the vertex*/
    int edge_nunber; /*the number of the edge*/
    adjList g; /*adjacent table*/
};
typedef ptrTogLNode adjacentTableGraph; /*a graph show by adjacent table*/

/*
 create a graph given the vertex number.
 @param vertexNum The verter number of the graph
 @return a graph with vertex but no any egdgs
 */
adjacentTableGraph createLGraph(int vertexNum) {
    adjacentTableGraph graph;

    vertex v;
    graph = (adjacentTableGraph) malloc(sizeof(struct gLNode));
    graph->vertex_number = vertexNum;
    graph->edge_nunber = 0;
    /*initialize the adjacent table*/
    for (v = 0; v < graph->vertex_number; v++) {
        graph->g[v].head = NULL;
    }
    return graph;
}

/*
 insert a edge to graph.We will distinct oriented graph and undirected graph
 The e->v1 and e->v2 are the vertexs' indexs in the adjacent table
 @param graph The graph you want to insert edge
 @param e The edge you want to insert the graph
 @param isOriented Whether the graph is oriented graph.If the graph is oriented
 we will set adjacent table graph[v1]->head=v2 and set graph[v1].head=v2
 otherwise we only set graph[v1].head=v2
 */
void insertEdgeToLink(adjacentTableGraph graph, edge e, int isOriented) {
    /*build node<v1,v2>*/
    ptrToAdjNode newNode;
    newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
    newNode->adjVerx = e->v2;
    newNode->weight = e->weight;
    newNode->next = graph->g[e->v1].head;
    graph->g[e->v1].head = newNode;
    /*if the graph is directed graph*/
    if (!isOriented) {
        newNode = (ptrToAdjNode) malloc(sizeof(struct adjNode));
        newNode->adjVerx = e->v1;
        newNode->weight = e->weight;
        newNode->next = graph->g[e->v2].head;
        graph->g[e->v2].head = newNode;
    }
}

/*
 build a graph stored by adjacent table
 */
adjacentTableGraph buildLGraph(int isOrdered) {
    adjacentTableGraph graph;
    edge e;
    vertex i;
    int vertex_num;

    scanf("%d", &vertex_num);
    graph = createLGraph(vertex_num);
    scanf("%d", &(graph->edge_nunber));
    if (graph->edge_nunber) {
        e = (edge) malloc(sizeof(struct eNode));
        for (i = 0; i < graph->edge_nunber; i++) {
            scanf("%d %d %d", &e->v1, &e->v2, &e->weight);
            e->v1--;
            e->v2--;
            insertEdgeToLink(graph, e, isOrdered);
        }
    }

    return graph;
}

/*----------------------define collection and some operator of graph's nodes-----------------------------*/

/*
 * The element of collection
 */
typedef vertex elementType;

/*
 * The index of root element,we use it as the collection name
 */
typedef vertex setName;

/*
 * A array to store the collection,we set the
 * first index is 0
 */
typedef elementType setType[MAX_VERTEX_NUM];

/*
 * Initialize collection
 * @param A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param n The length of the collection
 */
void initializeVSet(setType s, int n) {
    elementType x;
    for (x = 0; x < n; x++) {
        s[x] = -1;
    }
}

/*
 * Union two collections which is showed by root element.We will union smaller collection
 * to greater collection and we will update the quantity for greater collection
 * @param s A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param root1 The root element of the first collection
 * @param root2 The root element of the second collection
 */
void unionCollection(setType s, setName root1, setName root2) {
    /*
     * If root2's quantity greater than root1
     */
    if (s[root2] < s[root1]) {
        s[root2] += s[root1];
        s[root1] = root2;
    } else {
        s[root1] += s[root2];
        s[root2] = root1;
    }
}

/*
 * Find the element in which collection and use the root element
 * to represent this collection and return it.In this method,we will compress path
 * @param s A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param x The element we find which collection it in.
 */
setName find(setType s, elementType x) {
    if (s[x] < 0) {
        return x;
    } else {
        /*
         *compress path
         */
        return s[x] = find(s, s[x]);
    }
}

/*
 * Check v1 and v1 whether is belong to a same collection. If not union these
 * two collection,otherwise do nothing.
 * @param vSet A <code>elementType</code> array to store the collections,maybe
 * many collection will be stored in this array
 * @param v1 The index of node in the graph,also the element is the collection.
 * @param v2 The index of node in the graph,also the element is the collection.
 * @return If the two element is belong same collection,union them and return 1
 * else do nothing and return 0;
 */
int checkCircle(setType vSet, vertex v1, vertex v2) {
    setName root1 = find(vSet, v1);
    setName root2 = find(vSet, v2);
    if (root1 == root2) {
        return 0;
    } else {
        unionCollection(vSet, root1, root2);
        return 1;
    }
}

/*-------------define the minimal heap of edge-------------------*/

/*
 * Update the tree whose root element index is p into minimal heap,we use the edgs's
 * weight as the to construct the minimal heap.
 *
 * @param eset A array of edge to store the heap,because the edge is point variable
 * So the eSet is a edge type array,you can compare it with <code>int* arr</code>
 * @param The index of the root element.
 * @param n The length of the heap,the max index is n-1 in this case. And
 * this heap index is start from zero.
 */
void percDowm(edge eSet, int p, int n) {
    int parent, child;
    struct eNode x;

    x = eSet[p];
    for (parent = p; (parent * 2 + 1) < n; parent = child) {
        /*
         * Because the first index if from zero,so the left child
         * is parent*2+1
         */
        child = parent * 2 + 1;
        /*
         * Find smaller weigh between the left child and right child
         */
        if ((child != n - 1) && eSet[child].weight > eSet[child + 1].weight) {
            child++;
        }
        if (x.weight <= eSet[child].weight) {
            break;
        } else {
            eSet[parent] = eSet[child];
        }
    }
    eSet[parent] = x;
}

/*
 * Initialize eSet heap and update it to be the minimal heap
 * @param graph A graph which is stored by adjacent list
 * @param eSet A array of the edge as the minimal heap
 */
void initializeESet(adjacentTableGraph graph, edge eSet) {
    vertex v;
    ptrToAdjNode w;
    int counter = 0;
    for (v = 0; v < graph->vertex_number; v++) {
        for (w = graph->g[v].head; w; w = w->next) {
            /*
             * expect for put same edge to it,we only
             * put <v1,v2> to it.
             */
            if (v < w->adjVerx) {
                eSet[counter].v1 = v;
                eSet[counter].v2 = w->adjVerx;
                eSet[counter].weight = w->weight;
                counter++;
            }

        }
    }
    /*
     * Initialize the minimal heap
     */
    for (counter = graph->edge_nunber / 2; counter >= 0; counter--) {
        percDowm(eSet, counter, graph->edge_nunber);
    }
}

/*
 * Get minimal edge from the minimal weight heap
 * @param eset A array of edge to store the heap,because the edge is point variable
 * So the eSet is a edge type array,you can compare it with <code>int* arr</code>
 * @param The current size of the minimal heap
 * @return The index of the minimal edge in this heap(array)
 */
int getEdge(edge eSet, int currentSize) {
    if (currentSize == 0) {
        return currentSize - 1;
    }
    struct eNode temp = eSet[currentSize - 1];
    eSet[currentSize - 1] = eSet[0];
    eSet[0] = temp;
    percDowm(eSet, 0, currentSize - 1);
    return currentSize - 1;
}

/*
 * Implement the kruskal algorithms to find the minimal created tree
 * Algorithms thought:we choose the minimal edge from graph but don't
 * construct a circle each time. Until we choose the V-1 edges. The V
 * is equal with the quantity of the graph's vertex
 * In this program,we will use a counter to record the quantity of edges
 * At last of this method,if we check the quantity of the edge is less than
 * V-1, it indicates the graph is not collected,so -1 will be return,otherwise we will return
 * the minimal created tree total weight.
 * @param graph A graph which is stored by adjacent list
 * @param mst A A graph which is stored by adjacent list to store the minimal created tree
 * @return If the graph is collected,the weight of the minimal created tree
 * will be return, otherwise return -1
 */
int kruskal(adjacentTableGraph graph, adjacentTableGraph mst) {
    /*
     * totalWeight is to record the total weight
     * of the minimal created tree
     */
    weightType totalWeight;
    /*
     * eCounter is to record the quantity of edges which has been
     * insert the <code>mst<code>
     *
     * nextEdge is to record the next minimal edge in the minimal heap
     */
    int eCounter, nextEdge;

    /*
     *A set of the vertex to store the vertex and implement
     *some operation such as union find and so on
     */
    setType vSet;

    /*
     * A array of edge to as the minimal heap to store the egdes
     */
    edge eSet;

    /*
     * Initialize some variables
     */
    initializeVSet(vSet, graph->vertex_number);
    eSet = (edge) malloc((sizeof(struct eNode)) * (graph->edge_nunber));
    initializeESet(graph, eSet);
//    mst = createLGraph(graph->vertex_number);
    totalWeight = 0;
    eCounter = 0;
    nextEdge = graph->edge_nunber;
    while (eCounter < graph->vertex_number - 1) {
        nextEdge = getEdge(eSet, nextEdge);
        if (nextEdge < 0) {
            break;
        }
        /*
         * Check whether a circle between two vertex
         */
        if (checkCircle(vSet, eSet[nextEdge].v1, eSet[nextEdge].v2)) {
            insertEdgeToLink(mst, eSet + nextEdge, 0);
            totalWeight += eSet[nextEdge].weight;
            eCounter++;
        }
    }
    if (eCounter < graph->vertex_number - 1) {
        totalWeight = -1;
    }
    return totalWeight;
}

/*========Use DFS to print the result of the minimal created tree==========*/
/*
 * A method to access graph
 */
void visit(adjacentTableGraph graph, vertex v) {
    printf("%d ", v);
}

/*
 Depth first search a graph
 @param graph The graph need to search
 @param startPoint The fisrt point we start search the graph
 @paran int *visited The array we use to tag the vertex we has accessed.
 */
void DFS(adjacentTableGraph graph, vertex startPoint, int *visited) {
    ptrToAdjNode p;
    visit(graph, startPoint);
    p = graph->g[3].head;
    visited[startPoint] = 1;
    for (p = graph->g[startPoint].head; p; p = p->next) {
        if (visited[p->adjVerx] == 0) {
            DFS(graph, p->adjVerx, visited);
        }
    }
}

/*
 * Initialize a visited array that make them all to zero
 */
void initVisited(int length, int *visited) {
    int i;
    for (i = 0; i < length; i++) {
        visited[i] = 0;
    }
}

int main() {
    adjacentTableGraph graph = buildLGraph(0);
    adjacentTableGraph mst = createLGraph(graph->vertex_number);
    vertex visited[graph->vertex_number];
    weightType totalWeight = kruskal(graph, mst);
    printf("%d\n", totalWeight);
    /*initVisited(graph->vertex_number, visited);
    DFS(mst, 0, visited);*/
    return 0;
}