图算法:最小生成树算法之KrusKal

最小生成树算法之KrusKal

在上一章中，我们已经介绍了最小生成树的算法之一Prim算法，该算法是一个贪心算法，主要是随机选一个开始点，在找出与这个点相关的最小边，然后加入到生成树中，然后在一次重复上述过程，直到所有的点都遍历完为止。

今天要介绍的Kruskal算法，也是一种贪心策略，与Prim不一样的是，这里不是使用点来得到最小生成树，而是采用边来生成最小生成树。该算法的主要思想是，将图中所有的边排序后，依次取出边，然后判断边的两端点是否在生成树中，如果在，加入最小生成树将会产生环，如果不在，就可以加入生成树中，依次重复以上步骤，直到n-1步完成。

为啥是n-1步呢？因为图的顶点是n个，最小生成树的边必然是n-1条。接下来是该算法的伪代码形式。

Put the edges in a queue by weight
count =0;
while(count<n-1)
	get next edge(v,w)
	if(component(v)!=component(w))
		add to the tree
		meger component(v) and component(w)

对于时间复杂度，可以看出，O(mn).在这里，我们使用了一种很好的数据结构来实现该算法，可以将算法的时间复杂度变成O(mlogm)，其中m为边的个数。下面是具体的实现：

struct  edge_pair{
    int start;
    int end;
    int weight;
};
struct edgenode{
    int y;
    int weight;
    edgenode * next;
};
struct union_set{
    int p[MAX+1];
    int size[MAX+1];
    int n;
};

void set_union_initialize(union_set *s,int n)
{
    for(int i=1;i<=n;i++)
    {
        s->p[i]=i;//开始时，每一个节点的父节点设置为自己
        s->size[i]=1;//每一个节点独立成为一个子集
    }
    s->n=n;
}
int find(union_set *s,int start){
    if(s->p[start]==start)
        return start;//找到节点的根节点，并且返回
    return find(s,s->p[start]);
}

bool isSameComponent(union_set *s,int s1,int s2)
{
    //判断节点是否在同一连通性上面
    return find(s,s1)==find(s,s2);
}
void merge(union_set *s,int s1,int s2)
{
    int r1=find(s,s1);
    int r2=find(s,s2);
    //如果在同一节点上，则不做处理
    if(r1==r2) return;
    if(s->size[s1]>=s->size[s2])
    {
        //更新子集
        s->size[r1]+=s->size[r2];
        //更新父节点
        s->p[r2]=s->p[r1];
    }
    else{
        s->size[r2]+=s->size[r1];
        s->p[r1]=s->p[r2];
    }
}

bool cmp(const edge_pair &s1,const edge_pair &s2)
{
    if(s1.weight>s2.weight) return false;
    else return true;
}

void Kruskal_MST(graph *g)
{
    union_set s;
    
    set_union_initialize(&s,g->nvertex);
    
    sort(edgePair.begin(),edgePair.end(),cmp);
    
    for (int i=0; i<g->nvertex; i++) {
        if(!isSameComponent(&s, edgePair[i].start, edgePair[i].end))
        {
            cout<<edgePair[i].start<<"->"<<edgePair[i].end<<endl;
            merge(&s,edgePair[i].start, edgePair[i].end);
        }
    }
}

通过上面的代码，我们可以看出，使用正确的数据结构，可以将算法优化的更好。当然，我们必须清楚的认识到，该算法适用于稀疏图。