最小生成树 --------克鲁斯卡尔（kruskal）算法+邻接矩阵

最小生成树 --------克鲁斯卡尔（kruskal）算法+邻接矩阵:

这里采用邻接矩阵的存储方式，其中用到了直接插入排序，对边权值进行排序，另外，这里定义的e[]数组是存储每条边的相关信息（边的两端点+权值）

算法思想就是找边小的边，将边两端点加入构造结合内，循环找（因为是排好序的），循环从小到大就可以了，遇到连通值相同的顶点，如果他们之间有边值，需要舍弃掉，因为加入到构造集合内会形成回路，我们这里要找的是不能形成回路的。

代码如下：

#include <stdio.h>
#include <malloc.h>
#define inf 330
#define max 50

typedef struct  node{
	int no;
}bnode;//顶点结构体 

typedef struct graph{
	int a[max][max];
	int e,n;
	bnode nu[max];
}G;//邻接矩阵结构体 

typedef struct{
	int u;
	int v;
	int w;
}edge;//存储每条边的两个端点以及边值。 

//创建邻接矩阵 
void create(G &g, int b[max][max], int n, int e)
{ 
	int i ,j;
	g.e =e;//边数 
	g.n =n;//顶点数 
	for(i = 0; i<n; i++)
	{
		for(j = 0; j <n; j++)
	       g.a[i][j] = b[i][j];	
	}
	for(int i=0; i<n; i++)
	  g.nu[i].no = i;
}

void show(G g)
{
	int i ,j;
	printf("创建的邻接矩阵：\n");
	
	//下面代码段是显示矩阵的行列标识 
	printf("    ");
	for(int i =0; i<g.n; i++)
	printf("%d  ",i);
	printf("\n");
	
	for(i =0; i<g.n; i++)
	{
		printf("%d: ",i); 
		for(j=0; j<g.n; j++)
		{
			if(g.a[i][j] == inf)
				printf(" ∞") ;
			 else
			 	printf(" %d ",g.a[i][j]);
		}
		printf("\n");
	}
	printf("\n%d个顶点，%d条边 \n",g.n, g.e);
}

 //直接插入排序 
void insertfun(edge *a, int length)
{
	int i,j;
	edge temp;
	
	for(i=1; i<length; i++) //这里从数组1开始 
	{ 
	 //每i趟比较,i-1个前面的数的大小都是排好序的。
	  
		temp = a[i]; //将要比较的数放在temp中 
		for(j = i-1; j>=0; j--) //将temp之前的数循环与temp比较，注意，这里是与前面的数进行比较 
		{
			if(temp.w < a[j].w)  // 若前面的数比temp大,交换位置 
			{
				a[j+1] = a[j]; //整体交换 
			}
			else{
				break; 
			}
		}
		//此时的j = i-1-1 
		a[j+1] = temp; //最后将temp的值放入 j+1 
	}
}

//克鲁斯卡尔算法
/*也是采用贪心的思想，局部最优。
在这里，需要对e数组进行初始化，之后进行排序处理，按照权值的大小排列，
之后循环（因为构造的边数为顶点数-1）,循环体内要做的就是按顺序拿出每一条边，
（如果每边的连通分量不相同，则加入到构造集合内，接着修改对应的顶点的连通值） 
*/ 
void kruskal(G g)
{
	int visite[max];
	edge e[max];
	int k=0;
	int u1,v1,s1,s2;
	
	//初始化 
	for(int i =0; i< g.n; i++)	
		for(int j =0; j<i; j++)  //因为矩阵是对称。 
		{
			if(g.a[i][j]!=0&&g.a[i][j]!=inf)
			{
				e[k].u = i;
				e[k].v = j;
				e[k].w = g.a[i][j];
				k++;
			 } 
		}

	//对边进行排序 
	insertfun(e,g.e);	
	
	printf("\n排序结果： \n"); 
	for(int i =0; i<k; i++)
	{
		printf("(%d , %d): %d\n",e[i].u,e[i].v,e[i].w); 
    }

    //初始化连通编号 
    for(int i =0; i<g.n; i++)
      	visite[i] = i;
	   
	printf("\n克鲁斯卡尔求解结果：\n");
	 k = 1; //k为构造过程中的第k条边，初始化为第一条边开始
	 int j = 0;
	 while(k<g.n) //构造出来的边是g.n-1条 
	 {
	 	//找到两端点对应的连通值 
	 	u1 = e[j].u;
	 	v1 = e[j].v;
	 	s1 = visite[u1];
	 	s2 = visite[v1];
	 	
	 	if(s1 != s2)//如果相等就是构成回路，这里是找不形成回路的顶点。 
	 	{
	 		printf("(%d , %d): %d\n",u1,v1,e[j].w);
	 		++k;
	 		
	 		for(int i =0; i<g.n; i++) //找到s2，将其与端点s1的连通值一样，表示加入到构造集合里了 
	 		    if(visite[i] == s2 ) //找到visite[j]= s2的顶点 
	 		       visite[i] = s1;
		 }
		 j++;
	 }
	 
 } 

int main()
{
	G g; //注意，这里创建的是结构体类型变量，如果是结构体指针的话，创建的矩阵就是链式 
	int a[max][max]={
	             {0,5,8,7,inf,3},
                 {5,0,4,inf,inf,inf},
				 {8,4,0,5,inf,9},
				 {7,inf,5,0,5,6},
				 {inf,inf,inf,5,0,1},
				 {3,inf,9,6,1,0}
				 };
	int  n=6, e=10;
	
	//创建邻接矩阵 
	create(g,a,n,e);
	show(g);
	kruskal(g);
	return 0;	
}

程序运行如下：