最小生成树之kruskals算法C/C++

#include <bits/stdc++.h>
using namespace std; 
typedef char VertexType;
typedef struct EdgeNode{
    int adjvex;
    int weight;
    struct EdgeNode *nextedge;
}EdgeNode;

typedef struct VNode{
    VertexType data;
    int visited;
    struct EdgeNode *firstedge;
}VNode;

struct ALGraphStruct;
typedef struct ALGraphStruct *ALGraph;
struct ALGraphStruct{
    VNode vexs[1000];
    int vertexnum;
    int edgenum;
}; 

//创建邻接表 
ALGraph CreateALGraph()
{
    ALGraph g=(ALGraph)malloc(sizeof(struct ALGraphStruct));
    g->vertexnum=0;
    g->edgenum=0;
    return g;
} 

//查找顶点位置 
int Locates(ALGraph g,VertexType v)
{
    for(int i=0;i<g->vertexnum;i++)
        if(g->vexs[i].data==v)
            return i;
    return -1;
}

//增加顶点
void AddVertex(ALGraph g,VertexType v)
{
    int k=Locates(g,v);
    if(k!=-1)
        return ;
    int n=g->vertexnum;
    g->vertexnum++;
    g->vexs[n].data=v;
    g->vexs[n].visited=0;
    g->vexs[n].firstedge=NULL;
} 

//查找边
EdgeNode *FindEdge(ALGraph g,int i,int j)
{
    for(EdgeNode *p=g->vexs[i].firstedge;p!=NULL;p=p->nextedge)
        if(p->adjvex==j)
            return p;
    return NULL;
} 

//插入边
void InsertEdge(ALGraph g,int i,int j,int w)
{
    EdgeNode *s=(EdgeNode*)malloc(sizeof(struct EdgeNode));
    s->adjvex=i;
    s->weight=w;
    s->nextedge=g->vexs[j].firstedge;
    g->vexs[j].firstedge=s; 
}

//增加边 
void AddEdge(ALGraph g,VertexType v1,VertexType v2,int w)
{
    EdgeNode *s,*t; 
    int i=Locates(g,v1);
    int j=Locates(g,v2);
    if(i==-1 || j==-1)
        return ;
     s=FindEdge(g,i,j);
     if(s!=NULL){
         t=FindEdge(g,j,i);
         if(s->weight>w){
             s->weight=w;
             t->weight=w;
         }
         return;
     }
     InsertEdge(g,i,j,w);
     InsertEdge(g,j,i,w);
     g->edgenum++;
}

//第一个邻接点
int FirstEdge(ALGraph g,int i)
{
    EdgeNode *p=g->vexs[i].firstedge;
    if(p!=NULL)
        return p->adjvex;
    return -1;
} 

//下一个邻接点 
int NextEdge(ALGraph g,int i,int j)
{
    EdgeNode *p=FindEdge(g,i,j);
    if(p==NULL)
        return -1;
    p=p->nextedge;
    if(p==NULL)
        return -1;
    return p->adjvex;
}

//邻接表的初始化 
void ALGraphInit(ALGraph g)
{
    int n,m,w;
    char v,x,y;
    scanf("%d%d",&n,&m);
    getchar();
    for(int i=0;i<n;i++){
        v=getchar();
        AddVertex(g,v);  
    }
    for(int j=0;j<m;j++){
        getchar();
        x=getchar();
        y=getchar();
        w=getchar(); 
        AddEdge(g,x,y,w);
    }
    for(int k=0;k<n;k++)
        g->vexs[k].visited=1;
}

//最小生成树之kruskal算法
typedef struct{
    int start;
    int end;
    int weight;
}Edge;

void SwapEdge(Edge e[],int i,int j)
{
    Edge t;
    t=e[i];
    e[i]=e[j];
    e[j]=t;
} 

int SortEdge(ALGraph g,Edge e[])
{
    int m=0;
    for(int i=0;i<g->vertexnum;i++){
        for(EdgeNode *p=g->vexs[i].firstedge;p!=NULL;p=p->nextedge){
            e[m].start=i;
            e[m].end=p->adjvex;
            e[m].weight=p->weight;
            m++;
        }
    }     
    for(int i=0;i<g->vertexnum;i++){
        for(int j=i+1;j<g->vertexnum;j++){
            if(e[i].weight>e[j].weight)
                SwapEdge(e,i,j);
        }
    }
    return m;
}

int Root(int set[],int x)
{
    while(set[x]!=x)
        x=set[x];
    return x;
}

void Union(int set[],int x,int y)
{
    x=Root(set,x);
    y=Root(set,y);
    set[x]=y;
}

int FindMinEdge(Edge e[],int m,int set[],int k)
{
    int x,y;
    for(int i=k+1;i<m;i++){
        x=e[i].start;
        y=e[i].end;
        if(Root(set,x)!=Root(set,y))
            return i;
    }
    return -1;
}

void InitSet(int set[],int n)
{
    for(int i=0;i<n;i++)
        set[i]=i;
}

int kruskal(ALGraph g,ALGraph t)
{
    int lowcost=0;
    Edge e[1000];
    int set[1000];
    InitSet(set,g->vertexnum);
    int m=SortEdge(g,e);
    int count=0;
    int k=-1;
    char v1,v2;
    while(1){
        k=FindMinEdge(e,m,set,k);
        if(k==-1)
            return -1;
        lowcost+=e[k].weight;
        v1=g->vexs[e[k].start].data;
        v2=g->vexs[e[k].end].data;
        Union(set,e[k].start,e[k].end);
        AddVertex(t,v1);
        AddVertex(t,v2);
        AddEdge(t,v1,v2,e[k].weight);
        count++;
        if(count==g->vertexnum-1)
            return lowcost;
    }    
    return -1;
} 

int main()
{
    return 0;
}