• 一個連通圖的生成樹是圖的一個極小連通子圖,它包含所有頂點,但只有足以構成樹的n-1條邊
• 這意味著對生成樹來說,砍去它的任何一條邊,就會使生成樹變成非連通圖,若給他增加一條邊就會形成一條迴路
• 最小生成樹:權值最小的那顆生成樹叫~

• 最小生成樹的性質:

  1. 最小生成樹並不唯一,準確的來說是最小生成樹的樹形並不唯一
  2. 最小生成樹的權值之和唯一,並且是最小的
  3. 最小生成樹的邊數=頂點數-1

• 求最小生成樹有兩種經典演算法:普里姆演算法(prim)和克魯斯卡爾(kruskal)演算法

普里姆演算法求最小生成樹程式碼(貼上即能跑)

#include <iostream>
#include<stdlib.h>
 

#define maxSize 100
#define infinity 65535
using namespace std;
typedef struct{
    char vnode[maxSize];
    int edge[maxSize][maxSize];
    int n,e;
}MGraph; 

void createMGraph(MGraph &G){//鄰接矩陣構造圖 
    int i,j,n,e,k,w;
    cout<< "請輸入圖的頂點數和邊數"<<endl;
    cin>> G.n >> G.e;
    n=G.n;
    e=G.e;
    cout
 
<< "請輸入頂點"<<endl;
    for(i=0;i<n;i++){
        cin>> G.vnode[i]; 
    }
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            G.edge[i][j]=infinity;
        }
    }
    cout<< "請輸入邊的下標i,j"<<endl;
    for(k=0;k<e;k++){
        scanf("%d %d %d",&i,&j,&w);
        G.edge[i][j]=w;
        G.edge[j][i]=G.edge[i][j];
    } 
}

void
 
 minSpanTree_prim(MGraph G){//prim演算法求最小生成樹 
    int n,e,i,j,min,k,t;
    n=G.n;
    int lowcost[maxSize];//為0表示頂點加入最小生成樹,其他存放邊的權值 
    int adjvex[maxSize];//這個存放頂點下標,標明頂點是新增頂點,還是之前遍歷過的頂點 
    lowcost[0]=0;//把首個頂點(下標為0的頂點)加入到最小生成樹 
    adjvex[0]=0;//下標為0 
    for(i=1;i<n;i++){//迴圈0下標頂點與其他頂點的連線情況 (不從0開始是因為0 0表示自己和自己的環) 
        lowcost[i]=G.edge[0][i];//把0下標頂點和其他頂點組成的邊的權值存放到lowcost陣列中 
        adjvex[i]=0;//當前lowcost陣列中的邊的權值的起始頂點全部都是下標為0的頂點,而結束頂點則是序號為lowcost陣列下標的頂點 
    }
    cout<<"最小生成樹為:"<<endl; 
    for(t=1;t<n;t++){//迴圈所有頂點,構造最小生成樹 
        min=infinity;//初始化min,剛開始為一個極大值 
        j=1;k=0;
        while(j<n){//遍歷lowcost陣列 
            if(lowcost[j]!=0&&lowcost[j]<min){//除去已加入最小生成樹的頂點 
                min=lowcost[j];//找出lowcost陣列中最小的權值,並賦值給min 
                k=j;//記錄最小權值的下標 (這個k其實就是權值最小的那條邊的結束頂點) 
            }
            j++;
        }
        printf("(%d,%d)\n",adjvex[k],k);//列印權值最小的那條邊的起始頂點和結束頂點 
        lowcost[k]=0;//把k下標的頂點加入到最小生成樹 
        for(i=1;i<n;i++){//遍歷頂點 
            if(lowcost[i]!=0&&G.edge[k][i]<lowcost[i]){//要除去已加入最小生成樹的頂點 
                lowcost[i]=G.edge[k][i];//在k結點與其他頂點鄰接的權值和lowcost陣列中取較小的一方更新lowcost 
                adjvex[i]=k;//記錄較小權值的邊的起始頂點下標 
            }
        }
    }
}
int main(int argc, char** argv) {
    MGraph G;
    createMGraph(G);
    minSpanTree_prim(G);
    return 0;
}
    /*
    示例輸入:
        頂點數和邊數: 9 15
        輸入頂點:   0 1 2 3 4 5 6 7 8
        輸入頂點下標和權值: 
                4 7 7
                2 8 8
                0 1 10
                0 5 11
                1 8 12
                3 7 16
                1 6 16
                5 6 17
                1 2 18
                6 7 19
                3 4 20
                3 8 21
                2 3 22
                3 6 24
                4 5 26
    */

克魯斯卡爾演算法構造最小生成樹程式碼:

#include <iostream>
#include<algorithm>
#include<stdlib.h>
#define maxSize 100
#define infinity 65535
using namespace std;
typedef struct{//鄰接矩陣構造的圖結點 
    char vnode[maxSize];
    int edge[maxSize][maxSize];
    int n,e;
}MGraph; 

typedef struct{//邊集結點(存放邊的頂點下標和邊的權重) 
    int start;//邊起點 
    int end;//邊終點 
    int w;//邊權值 
}Road; 
Road road[maxSize];//邊集陣列
int parent[maxSize];
int getRoot(int i){//此函式用於找到下標為i的頂點在生成樹中的父節點 (並查集) 
    while(parent[i]!=i){  
        i=parent[i];
    }
    return i;
}

bool compare(Road x,Road y){//自定義結構體比較方式,按結構體中的權值升序排 
    return x.w<y.w;
}

void createMGraph(MGraph &G){//建立圖 
    int i,j,n,e,k,w;
    cout<< "請輸入圖的頂點數和邊數"<<endl;
    cin>> G.n >> G.e;
    n=G.n;
    e=G.e;
    cout<< "請輸入頂點"<<endl;
    for(i=0;i<n;i++){
        cin>> G.vnode[i]; 
    }
    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            G.edge[i][j]=infinity;
        }
    }
    cout<< "請輸入邊的下標i,j"<<endl;
    for(k=0;k<e;k++){
        scanf("%d %d %d",&i,&j,&w);
        G.edge[i][j]=w;
        road[k].start=i;//建立的時候就給邊集陣列賦值
        road[k].end=j;
        road[k].w=w;
        G.edge[j][i]=G.edge[i][j];//根據無向圖鄰接矩陣的對稱性賦值
    } 
}

int kruskal(MGraph G){//克魯斯卡爾演算法 
    int a,b,sum=0;
    int e=G.e;
    for(int i=0;i<G.e;i++){//初始化根結點下標陣列 
        parent[i]=i;//為存放根節點下標陣列賦初值,自身作為自己的根節點 
    } 
    sort(road,road+e,compare);//按邊集陣列中的權值由小到大排序 
    for(int i=0;i<e;i++){//遍歷已經排好序的邊 
        a=getRoot(road[i].start);//獲取開始頂點在生成樹中的父節點
        b=getRoot(road[i].end);//獲取終結頂點在生成樹中的父節點
        if(a!=b){//當ab不等說明兩者不是同一個父節點,不會構成環 
            parent[a]=b;//把b點作為孩子加在a的後面 
            printf("(%d,%d)\n",road[i].start,road[i].end);//列印構成最小生成樹的邊
            sum+=road[i].w;//最小生成樹的權值總和
        }
    }
    printf("sum=%d\n",sum);
    return sum;
}
int main(int argc, char** argv) {
    MGraph G;
    createMGraph(G);
    kruskal(G);
    return 0;
}
/*
    示例輸入:
        頂點數和邊數: 9 15
        輸入頂點:   0 1 2 3 4 5 6 7 8
        輸入頂點下標和權值: 
                4 7 7
                2 8 8
                0 1 10
                0 5 11
                1 8 12
                3 7 16
                1 6 16
                5 6 17
                1 2 18
                6 7 19
                3 4 20
                3 8 21
                2 3 22
                3 6 24
                4 5 26
    */