课堂笔记：最小生成树

最小生成树（minimal spanning tree）
生成树的代价：设G=（V，E）是一个无向连通网，生成树上各边的权值之和称为该生成树的代价。
最小生成树：在图G所有生成树中，代价最小的生成树称为最小生成树。
MST（ minimum spanning tree）性质
假设G=(V, E)是一个无向连通网，U是顶点集V的一个非空子集。若(u, v)是一条具有最小权值的边，其中u∈U，v∈V－U，则必存在一棵包含边(u, v)的最小生成树。
MST性质的应用
构造最小代价生成树
两种方法：Prime法：加点法，Kruskal方法：加边法
Prim算法
基本思想：
设G=(V, E)是具有n个顶点的连通网，T=(U, TE)是G的最小生成树， T的初始状态为U={u0}（u0∈V），TE={ }，重复执行下述操作： 在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。
数据结构设计
数组lowcost[n]：用来保存集合V-U中各顶点与集合U中顶点最短边的权值，lowcost[v]=0表示顶点v已加入最小生成树中；
数组adjvex[n]：用来保存该边所依附的（集合V-U中各顶点与集合U中顶点的最短边）集合U中的顶点。
Prim算法——伪代码
1、初始化两个辅助数组lowcost（=arc[0][i]）和adjvex(=0)(0是始点)； 2、输出顶点u0，将顶点u0加入集合U中；
3、重复执行下列操作n-1次
3.1、在lowcost中选取最短边(lowcost[k])，取对应的顶点序号k；
3.2、输出顶点k和对应的权值；
3.3、将顶点k加入集合U中（lowcost[k]=0）；
3.4、调整数组lowcost和adjvex；

Void prime(MGraph G){
          
	for(int i=1;i<G.vertexNu;i++){
              
		lowcost[i]=G.arc[0][i];  
		adjvex[i]=0;     
	}     
	lowcost[0]=0;
	for(i=1;i<G.vertexNum;i+++){
              
		k=MinEdge(lowcost,G.vertexNum)         
		cout<<K<<adjvex[k]<<lowcost[k];         
		lowcost[k]=0;
		for(j=1;j<G.vertexNum;j++)           
			if((G.arc[k][j]<lowcost[j]){
                    
				lowcost[j]=G.arc[k][j];               
				arcvex[j]=k;            
			}     
	} 
}

时间复杂性：O(n2)，适用于稠密图。
Kruskal算法
基本思想：
1、设无向连通网为G＝(V, E)，令G的最小生成树为T＝(U, TE)，其初态为U＝V，TE＝{ }，
2、然后，按照边的权值由小到大的顺序，考察G的边集E中的各条边。2.1、若被考察的边的两个顶点属于T的两个不同的连通分量，则将此边作为最小生成树的边加入到T中，同时把两个连通分量连接为一个连通分量；
2.2、若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路；
3、如此下去，当T中的连通分量个数为1时，此连通分量便为G的一棵最小生成树。
Kruskal算法思想
1、初始化：U=V； TE={ }；
2、循环直到T中的连通分量个数为1
2.1、在E中寻找最短边(u，v);
2.2、如果顶点u、v位于T的两个不同连通分量，则
2.2.1、将边(u，v)并入TE；
2.2.2、将这两个连通分量合并为一个；
2.3、在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；
Kruskal算法实现中的三个关键问题
1、图的存储结构
采用边集数组存储图。
2、如何判断一条边所依附的两个顶点在同一个连通分量中(并查集)
定义Parent[i]数组。数组分量的值表示顶点i的双亲节点（初值为-1；）
当一条边（u,v）的两个顶点的根结不同时，这两个结点属于不同的连通分量（利用parent 数组查找一棵树的根节点。当一个结点n的parent==-1，树的根节点即为n）
3、如何将一条边所依附的两个顶点合并到同一个连通分量中
要进行联通分量的合并 ，其中一个顶点所在的树的根节点为vex1，另一个顶点所在的树的根节点为vex2，则：parent[vex2]=vex1；

int Find(int *parent, int node){
       
	int f;  
	f=node;  
	while(parent[f]>-1)   
		f=parent[f];  
	return f; 
}
int main(){
          
	int arcNum, int vertexNum;     
	EdgeNode *edge;     
	int *parent;
	cout<<"please input the number of vertexNum:"; 
	cin>>vertexNum;     
	cout<<"please input the number of edges:"; 
	cin>>arcNum;     
	edge=new EdgeNode[arcNum]; 
	parent=new int[vertexNum];
	for(int i=0;i<arcNum;i++){
        
		cout<<"Please input the edges:";  
		cin>>edge[i].from>>edge[i].to>>edge[i].weight;     
	}
	sort(edges, G);   
	for (i=0;i<vertexNum;i++)  
		parent[i]=-1;
	int k=0,begin,end,count=0;     
	cout<<"next is the MST :"<<endl;
	for (k=0;k<arcNum;k++){
               
		begin=edge[k].from; 
		end=edge[k].to;           
		int m,n;         
		m=Find(parent,begin); 
		n=Find(parent,end);         
		if(m!=n){
     
			cout<<begin<<","<<end<<","<<edge[k].weight<<endl;             
			parent[n]=m;              
			count++;             
			if(count==vertexNum-1) 
				break;        
		}    
	}    
	return 0; 
}

Kruskal算法的时间复杂性分析
边集数组排序，时间复杂性O(eloge)，在e条边中选边，时间复杂性为O(e)，因此时间复杂性为O(eloge)。