【c++】PrimアルゴリズムとKruskalアルゴリズムの完全なコード

最小生成ツリーの2つの方法.
Primアルゴリズム:

#include 
#define INF 99999
using namespace std;

const int N=6;
bool visit[N];
int dist[N]={0};
int graph[N][N]={{},
                 {}   //    
                 };

int prim(int cur){
    int index=cur;
    int sum=0;
    cout<<index<<" ";
    memset(visit,false,sizeof(visit));
    visit[cur]=true;
    for(int i=0;i<N;i++)
        dist[i]=graph[cur][i];
    for(int i=1;i<N;i++){
        int min=INF;
        for(int j=0;j<N;j++){
            if(!visit[j]&&dist[j]<min){
                min=dist[j];
                index=j;
            }
        }
        visit[index]=true;
        cout<<index<<" ";
        sum+=min;
        for(int j=0;j<N;j++){
            if(!visit[j]&&dist[j]>graph[index][j])   //    ，             ，   dist
                dist[j]=graph[index][j];
        }
    }
    cout<<endl;
    return sum;
}

int main(){
    cout<<prim(0)<<endl;    //   0  
}

Kruskalアルゴリズム:

#include 
#include 
#define N 7
using namespace std;

typedef struct _node{
    int val;
    int start;
    int end;
}Node;

Node V[N];

int cmp(const void *a, const void *b){
    return (*(Node *)a).val-(*(Node*)b).val;
}

int edge[N][N]={};   //  
int father[N]={0};
int cap[N]={0};

void make_set(){    //     ，            ，          
    for(int i=0;i<N;i++){
        father[i]=i;
        cap[i]=1;
    }
}

int find_set(int x){    //           ，             ，            
    if(x!=father[x]) father[x]=find_set(father[x]);
    return father[x];
}

void Union(int x,int y){   // x,y        
    x=find_set(x);
    y=find_set(y);
    if(x==y) return;
    if(cap[x]<cap[y]) father[x]=find_set(y);
    else{
        if(cap[x]==cap[y]) cap[x]++;
        father[y]=find_set(x);
    }
}

int Kruskal(int n){
    int sum=0;
    make_set();
    for(int i=0;i<N;i++){  //            
        if(find_set(V[i].start)!=find_set(V[i].end)){   //         
            Union(V[i].start,V[i].end);  //      
            sum+=V[i].val;
        }
    }
    return sum;
}

int main(){
    for(int i=0;i<N;i++){   //       
        V[i].start=edge[i][0];
        V[i].end=edge[i][N];
        V[i].val=edge[i][……];
    }
    qsort(V,N,sizeof(V[0]),cmp);
    cout<<Kruskal(0)<<endl;
    return 0;
}