构建最小生成树Kruskal算法

#include<stdio.h>
#include<stdlib.h>

#define MAX 32767
#define SIZE 100
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status ;
typedef char VertexType ;

typedef struct
{
int vex ;
int weight ;
ArcNode *next ;
}ArcNode;

typedef struct
{
VertexType data ;
ArcNode *first ;
}VList[SIZE] ;

typedef struct
{
VList vertices ;
int vernum , arcnum ;
}ALGraph ;

ALGraph *G = (ALGraph *)malloc(sizeof(ALGraph));

int Locate(ALGraph *G , char a )
{
int i = 0 ;
while(i < G->vernum)
{
if(G->vertices[i].data == a)
{
return i ;
}
++i ;
}
return -1 ;
}

//构建邻接表
Status CreateALGraph(ALGraph *G )
{
int i , j , k ;
int w ;
char v1 , v2 ;
ArcNode *p ;

for(i = 0 ; i < G->vernum ; ++i)
{
	scanf_s("%c",&G->vertices[i].data, sizeof(char));
	G->vertices[i].first = NULL ;
}

for(k = 0 ; k< G->arcnum ; ++k)
{
	scanf_s("%c%c%d", &v1 ,sizeof(char) , &v2, sizeof(char) , &w , sizeof(int)) ;
	i = Locate(G , v1) ;
	j = Locate(G , v2) ;

	p = (ArcNode *)malloc(sizeof(ArcNode)) ;
	p->next = G->vertices[i].first ;
	G->vertices[i].first = p ;

	p = (ArcNode *)malloc(sizeof(ArcNode)) ;
	p->next = G->vertices[j].first ;
	G->vertices[j].first = p ;
}
return OK ;

}

ALGraph *MG = (ALGraph *)malloc(sizeof(ALGraph));

int *visited = (int *)calloc(G->vernum , sizeof(int)) ;

typedef struct
{
int v1 , v2 ;
int weight ;
}Arc;

Arc *arc = (Arc *)calloc(G->arcnum , sizeof(Arc)) ;

void Sort_Arc(ALGraph *G )
{
int i , j ,flag , pos;
int num = 0 ;
ArcNode *p ;
Arc temp ;
for(i = 0 ; i < G->vernum ; ++i )
{
p = G->vertices[i].first ;
while§
{
arc[num].v1 = i ;
arc[num].v2 = p->vex ;
arc[num].weight = p->weight ;
p = p->next ;
}
}

for(i = 0 ; i < G->arcnum-1 ; ++i )
{
	flag = 0 ;
	pos = G->arcnum-1 ;
	for(j = i ; j < pos ; ++j )
	{
		if(arc[j].weight > arc[j+1].weight)
		{
			temp = arc[j] ;
			arc[j] = arc[j+1] ;
			arc[j+1] = temp ;
			pos = j + 1 ;
			flag = 1 ;
		}
		if(flag == 0)
		{
			break ;
		}
	}
}

}

void Kruskal(ALGraph *G )//全部权值中找最小
{
int i , j ;
int find ;
int flag ; //是否有相接边
ArcNode *C, *CC , *p1 ;

MG->arcnum = G->vernum -1 ;
MG->vernum = G->vernum ;
for(i = 0 ; i < G->vernum ; ++i)
{
	MG->vertices[i].data = G->vertices[i].data ;
	MG->vertices[i].first = NULL ;
}


for(i = j = 0 ; i <MG->arcnum ; ++i ,++j )
{
	flag = 0 ;
	if(visited[arc[i].v1] == 1 && visited[arc[i].v2] == 1 )
	{
		C = MG->vertices[arc[j].v1].first ;
		while(C)//遍历查看是否有构成回路
		{
			find = C->vex ;
			CC = MG->vertices[find].first ;
			while(CC)
			{
				if(CC->vex == arc[j].v2 )
				{
					flag = 1 ;
					break ;
				}
				CC = CC->next ;
			}
			if(flag == 1)
			{
				break ;
			}
			C = C->next ;
		}
	}
	if(flag == 0)//无回路,构建边
	{
		p1 = (ArcNode *)malloc(sizeof(ArcNode)) ;
		p1->vex = arc[j].v2 ;
		p1->weight = arc[j].weight ;
		p1->next = MG->vertices[j].first ;
		MG->vertices[j].first = p ;
		visited[arc[j].v1] = visited[arc[i].v2] = 1 ;
	}
	else//该边形成回路
	{
		++j ;
	}
}

}