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

Prim算法

连通分量是指图的一个子图，子图中任意两个顶点之间都是可达的。最小生成树是连通图的一个连通分量，且所有边的权值和最小。

最小生成树中，一个顶点最多与两个顶点邻接；若连通图有n个顶点，则最小生成树中一定有n-1条边。

Prim算法需要两个线性表来进行辅助：

• visited:

标记已经加入生成树的顶点；（它的功能可以由tree取代）

初始状态：生成树根节点为真，其它为0。

• tree:

记录生成树，tree[x]保存顶点x的直接根节点下标，若x为树的根节点则tree[x]为其自身。

初始状态：根节点为其自身，其它顶点为NULL。

• low:

low[i]记录生成树中顶点与生成树外顶点i所有边中的最小值。

初始状态：生成树根节点与其它边之间的权值。

Prim算法采用贪心的思想进行设计：

(1) 初始化：将起始点加入生成树中

(2) 在生成树中的顶点与其它顶点之间的边中寻找最小的边加入生成树中（更新visited,tree）;

(3) 搜索新加入顶点与所有生成树外顶点i之间边，若小于原有low[i]则更新low[i];

(4) 重复执行，直至生成树中包含了所有顶点。

Prim算法与Dijsktra算法非常类似，两者在执行过程上的显著区别在于：Prim算法按边进行搜索，将最小边加入生成树中；

Dijsktra算法按顶点进行搜索，选择树外顶点与源点之间最短的边（路径）加入生成树中。

【你如果非手算不可的话】记得在加入新顶点时，标记已加入到生成树中的边以及生成树顶点之间的边。

#define N 10000
int map[N][N],low[N],visited[N],tree[N];
int m, n;

int prim()//以0作为起点（生成树的根）
{
    int i, j, pos, min, result=0;
    memset(visited,0,sizeof(visited));
    visited[0] = 1;
    pos = 0;
    //init low
    for(i = 0; i < n; i++) {
       tree[i] = -1;//
       if(i != pos) {
          low[i] = map[pos][i];
       }
    }
    tree[0] = 0;//

    //get mini
    for(i = 0; i < n - 1; i++) {
        min = INT_MAX;
        //找到与i之间代价最小的节点pos
        for(j = 0; j < n; j++) {
            if(visited[j] == 0 && min > low[j] ) {
                min = low[j]; 
                pos = j;
             }
        }
        tree[pos] = i;
        result += min;
        visited[pos] = 1;
        //update low
        for(j = 0; j < n; j++) {
            if(visited[j] == 0 && low[j] > map[pos][j]) {
                low[j] = map[pos][j];
            }
        }
    }
    return result;  //返回总代价
}

Kruskal算法

Kruskal算法的步骤：

1.对所有边进行从小到大的排序。

2.每次选一条边（最小的边），如果如果形成环，就不加入(u,v)中，否则加入。那么加入的(u,v)一定是最佳的。

【如果你非手算不可的话】从小到大地搜索所有边，若不产生环则加入生成树中。Kruskal算法是手动求最小生成树的不错选择。

采用递归的方式判断环的存在：

int find(int x) //find the root
{
    if (parent[x] == x) {
        return x;
    }
    else {
        parent[x] = find(parent[x]);
        return parent[x];
    }
}

parent[x]保存顶点x的直接根节点下标，若x为树的根节点则parent[x]为其自身。find函数可以求出节点x的根节点，从而判断是否有环形成。

int head[N],tail[N],weight[N];
int parent[N],sorted[N];

int cmp(const void *ip, const void *jp)
{
    int i = *(int *)ip, j = *(int *)jp;
    return weight[i] - weight[j];
}

int find(int x) //find the root
{
    if (parent[x] == x) {
        return x;
    }
    else {
        parent[x] = find(parent[x]);
        return parent[x];
    }
}

//m vertex, n edge
int kruskal()
{
    int count = 0, x, y, i, e, ans = 0;
    //init
    for(i = 0; i < n; i++) {
        parent[i] = i;
    }
    for(i=0; i < n; i++) {
        sorted[i] = i;
    }
    //sort(r,r+m,cmp);
    qsort(sorted, m, sizeof(int), cmp);
    for(i = 0; i < m; i++)
    {
        e = sorted[i];
        x = find( head[e] );
        y = find( tail[e] );
        if(x != y) {
            ans += weight[e];
            parent[x] = y;
            count++;
        }
    }
    if (count < n - 1) { //无法连通
        return -1;
    }
    return ans;
}