最小生成树

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

#define MAXVERTEX 20

typedef struct {
    char vexs[MAXVERTEX];//顶点向量
    int arcs[MAXVERTEX][MAXVERTEX];//邻接矩阵
    int vexnum, arcnum;//（无向）图当前顶点数和弧数
}Graph;

typedef struct {
    char v, w;
    int edge;
}Treever;



//创建图，读取：顶点数，顶点向量，邻接矩阵;-1代表无穷大;0是自环，不考虑
void creatGraph(Graph &G) {
    scanf_s("%d\n", &G.vexnum);
    for (int i = 0; i < G.vexnum; i++) {
        scanf_s("%c", &G.vexs[i]);
    }
    int a = 0;
    for (int i = 0; i < G.vexnum; i++)
    {
        for (int j = 0; j < G.vexnum; j++) {
            scanf_s("%d", &G.arcs[i][j]);
            if (G.arcs[i][j] > 0)
                a++;
            if (G.arcs[i][j] == -1)
                G.arcs[i][j] = INT_MAX;
        }
    }
    G.arcnum = a / 2;
}

void Prim(Graph & G, Treever MinTREE[]) {
    int flag[MAXVERTEX] = { 0 };
    int i, j, mincost = INT_MAX, key1=0,key2 = 0;
    for (i = 1; i < G.vexnum; i++) {//n个顶点，则有n-1个边，即n-1个Treever
        MinTREE[i].v = G.vexs[i];
        MinTREE[i].edge = INT_MAX;
    }
    
    for (i = 1; i < G.vexnum; i++) {//i用来记录进行了n-1次循环
        mincost = INT_MAX;
        for (j = 1; j < G.vexnum; j++) {//比较矩阵key1行每个弧长与Tree对应的，改为小值
            if (G.arcs[key1][j] < MinTREE[j].edge&&flag[j] != 1)
            {
                MinTREE[j].edge = G.arcs[key1][j];//改变弧长时同时改变对应的邻接点
                MinTREE[j].w = G.vexs[key1];
            }
            if (MinTREE[j].edge < mincost&&flag[j] != 1)
            {
                mincost = MinTREE[j].edge;//记录最短弧长
                key2 = j;
            }
        }
        flag[key2] = 1;
        key1 = key2;
    }
    
}
//从小到大
void sortlist1(Graph & G, Treever list[]) {//构建排序邻接表(不重复，去掉对称)，从小到大
    int i, j, a = 1;
    for (i = 0; i < G.vexnum; i++) {
        for (j = i + 1; j < G.vexnum; j++) {
            if (G.arcs[i][j] != INT_MAX) {
                list[a].edge = G.arcs[i][j];
                list[a].v = G.vexs[i];
                list[a].w = G.vexs[j];
                a++;
            }
        }
    }
    //选择排序
    int min,mini=21;
    Treever temp;
    for (j = 1; j <= G.arcnum; j++)//list数组元素个数等于弧数
    {
        min = list[j].edge;
        mini = j;
        for (i = j+1; i <= G.arcnum; i++)
        {
            if (list[i].edge < min) {
                min = list[i].edge;
                mini = i;
            }
        }
        if (mini != j) {
            temp = list[mini];
            list[mini] = list[j];
            list[j] = temp;
        }
    }
}

int index(char h) {
    int a = 0;
    if (h >= '0'&&h <= '9')
        a = h - '0';
    else if (h >= 'a'&&h <= 'z')
    {
        a = h - 'a';
    }
    else
    {
        if (h >= 'A'&&h <= 'Z')
            a = h - 'A';
    }
    return a;
}
int findroot(int root[], char l) {//不能只通过判断两点是否在同一集合上，来判断是否有回路；需要找根，根相同说明两点连上有回路
    int a = index(l);
    while (root[a] != -1)
        a = root[a];
    return a;
}

void Kruskal(Graph & G, Treever MinTREE[]) {
    Treever list[MAXVERTEX];
    sortlist1(G, list);
    int root[MAXVERTEX],i,j,p1,p2,k=1;
    for (i = 0; i < G.vexnum; i++)
        root[i] = -1;
    for (i = 1; i <= G.arcnum; i++) {
        p1 = findroot(root, list[i].v);
        p2 = findroot(root, list[i].w);
        if (p1 != p2)
        {
            MinTREE[k] = list[i];
            root[index(list[i].w)] = index(list[i].v);
            k++;
        }
    }
}

int FirstAdj(Graph &G, int v) {
    int i;
    for (i = 0; i < G.vexnum; i++) {
        if (G.arcs[v][i] < INT_MAX&&G.arcs[v][i] != 0)
            return i;
    }
    return -1;
}

int NextAdj(Graph &G, int v, int w) {
    int i;
    for (i = w+1; i < G.vexnum; i++) {
        if (G.arcs[v][i] < INT_MAX&&G.arcs[v][i] != 0)
            return i;
    }
    return -1;
}

void DFS(Graph &G, int v,int visited[]) {
    visited[v] = 1;
    for (int w = FirstAdj(G, v); w >= 0; w = NextAdj(G, v, w))
        if (!visited[w])
            DFS(G, w, visited);
}

int connect(Graph&G) {//若连通，只从顶点0开始深度搜索，即可遍历全部顶点
    int visited[MAXVERTEX] = { 0 };
    DFS(G, 0, visited);
    for (int i = 0; i < G.vexnum; i++) {
        if (visited[i] == 0)
            return 0;
    }
    return 1;
}
//从大到小
void sortlist2(Graph & G, Treever list[]) {//构建排序邻接表(不重复，去掉对称)，从大到小
    int i, j, a = 1;
    for (i = 0; i < G.vexnum; i++) {
        for (j = i + 1; j < G.vexnum; j++) {
            if (G.arcs[i][j] != INT_MAX) {
                list[a].edge = G.arcs[i][j];
                list[a].v = G.vexs[i];
                list[a].w = G.vexs[j];
                a++;
            }
        }
    }
    //选择排序
    int max,maxi = 21;
    Treever temp;
    for (j = 1; j <= G.arcnum; j++)//list数组元素个数等于弧数
    {
        max = list[j].edge;
        maxi = j;
        for (i = j + 1; i <= G.arcnum; i++)
        {
            if (list[i].edge > max) {
                max = list[i].edge;
                maxi = i;
            }
        }
        if (maxi != j) {
            temp = list[maxi];
            list[maxi] = list[j];
            list[j] = temp;
        }
    }
}


//去边法
void De_edge(Graph & G, Treever MinTREE[]) {
    Treever list[MAXVERTEX];
    sortlist2(G, list);
    int key,a=1,ard=G.arcnum;
    for (int i = 1; i <= ard; i++) {
        key = G.arcs[index(list[i].v)][index(list[i].w)];
        G.arcs[index(list[i].v)][index(list[i].w)] = G.arcs[index(list[i].w)][index(list[i].v)] = INT_MAX;
        G.arcnum--;
        if (!connect(G)) {
            G.arcs[index(list[i].v)][index(list[i].w)] = G.arcs[index(list[i].w)][index(list[i].v)] = key;
            G.arcnum++;
            MinTREE[a] = list[i];
            a++;
        }
    }

}

void print(Graph & G, Treever MinTREE[]) {
    for (int i = 1; i < G.vexnum; i++)
        printf("%c ,%d ,%c\n", MinTREE[i].v, MinTREE[i].edge, MinTREE[i].w);
}

int main() {
    Graph G;
    Treever MinTREE[MAXVERTEX];
    creatGraph(G);
    printf("Prim算法：\n"); 
    Prim(G, MinTREE);
    print(G, MinTREE);
    printf("Kruskal算法：\n");
    Kruskal(G, MinTREE);
    print(G, MinTREE);
    printf("去边法：\n");
    De_edge(G, MinTREE);
    print(G, MinTREE);
    system("PAUSE");
}