概念

連通圖的生成樹是一個極小的連通子圖，它含有圖中全部的n個頂點，但只有足以構成一顆樹的n-1條邊。

構造連通網的最小代價生成樹簡稱為最小生成樹。

Prim 算法

算法思路

1. 定義2個數組，adjvex 用來保存相關頂點下標，lowcost 保存頂點之間的權值
2. 初始化2個數組, 從v0開始尋找最小?成樹, 默認v0是最小生成樹上第一個頂點
3. 循環lowcost 數組,根據權值,找到頂點 k;
4. 更新lowcost 數組
5. 循環所有頂點,找到與頂點k 有關系的頂點. 并更新lowcost 數組與adjvex 數組;

注意更新lowcost 數組與adjvex 數組的條件:

1. 與頂點k 之間有連接
2. 當前結點 j 沒有加入過最小生成樹;
3. 頂點 k 與 當前頂點 j 之間的權值 小于 頂點j 與其他頂點 k 之前的權值. 則更新. 簡單說就是要比較之前存儲的值要小,則更新;

代碼實現

/*
 Prim算法生成最小生成樹
 */

void MiniSpanTree_Prim(MGraph G) {
    int min, i, j, k;
    int sum = 0;
    
    int adjvex[MAXVEX];
    int lowcost[MAXVEX];
    
    lowcost[0] = 0;
    adjvex[0] = 0;
    
    for (i = 1; i < G.numVertexes; i++) {
        lowcost[i] = G.arc[0][i];
        adjvex[i] = 0;
    }
    
    for (i = 1; i < G.numVertexes; i++) {
        min = INFINITYC;
        
        j = 1;
        k = 0;
        for (j = 1; j < G.numVertexes; j++) {
            if (lowcost[j] != 0 && lowcost[j] < min) {
                min = lowcost[j];
                k = j;
            }
        }
        
        printf("(V%d, V%d) = %d\n", adjvex[k], k , G.arc[adjvex[k]][k]);
        sum += G.arc[adjvex[k]][k];
        lowcost[k] = 0;
        
        for (j = 1; j < G.numVertexes; j++) {
            if (lowcost[j] != 0 && G.arc[k][j] < lowcost[j]) {
                lowcost[j] = G.arc[k][j];
                adjvex[j] = k;
            }
        }
    }
    printf("sum = %d\n", sum);
}

Kruskal 算法

算法思路

1. 將鄰接矩陣轉化成邊表數組；
2. 對邊表數組根據權值按照從小到大的順序排序；
3. 遍歷所有的邊， 通過parent 數組找到邊的連接信息，避免閉環問題；
4. 如果不存在閉環問題,則加入到最小生成樹中，并且修改parent 數組；

代碼實現

typedef struct Edge {
    int begin;
    int end;
    int weight;
} Edge;

/*
 Prim算法生成最小生成樹
 */

void Swapn(Edge *edges, int i, int j) {
    int temp;
    temp = edges[i].begin;
    edges[i].begin = edges[j].begin;
    edges[j].begin = temp;
    
    temp = edges[i].end;
    edges[i].end = edges[j].end;
    edges[j].end = temp;
    
    temp = edges[i].weight;
    edges[i].weight = edges[j].weight;
    edges[j].weight = temp;
}

void Sort(Edge edges[], MGraph *G) {
    int i, j;
    for (i = 0; i < G->numEdges; i++) {
        for (j = i + 1; j < G->numEdges; j++) {
            if (edges[i].weight > edges[j].weight) {
                Swapn(edges, i, j);
            }
        }
    }
}

int Find(int *parent, int f) {
    while (parent[f] > 0) {
        f = parent[f];
    }
    return f;
}

void MiniSpanTree_Kruskal(MGraph G)  {
    int i, j, n, m;
    int sum = 0;
    int k = 0;
    
    Edge edges[MAXVEX];
    
    for (i = 0; i < G.numVertexes; i++) {
        for (j = i + 1; j < G.numVertexes; j++) {
            if (G.arc[i][j] < INFINITYC) {
                edges[k].begin = i;
                edges[k].end = j;
                edges[k].weight = G.arc[i][j];
                k++;
            }
        }
    }
    
    Sort(edges, &G);
    
    int parent[MAXVEX] = {0};
    for (i = 0; i < G.numEdges; i++) {
        m = Find(parent, edges[i].begin);
        n = Find(parent, edges[i].end);
        
        if (m != n) {
            parent[m] = n;
            sum += edges[i].weight;
            printf("(%d, %d) %d\n", edges[i].begin, edges[i].end, edges[i].weight);
        }
    }
    printf("sum = %d\n", sum);
}