Prim和Kruskal最小生成树

//运行程序所需要完成的结构体和类定义以及函数
#include <iostream>
#include <queue>
#include <map>

using namespace std;
//定义并查集
class UFset {
  private:
    int* parent;
  public:
    UFset(int n) {
        parent = new int [n];
        for (int i = 0; i < n; i++)
            parent[i] = i;
    }
    int Find(int x) {
        return parent[x] == x ? x : Find(parent[x]);
    }
    void Union(int x1, int x2) {
        parent[Find(x1)] = Find(x2);
    }

    bool Same(int x1, int x2) {
        return Find(x1) == Find(x2);
    }
};
//定义每一条边edge的起点和终点以及权重
struct EdgeNode {
    int Begin;
    int End;
    int key;
    EdgeNode() {
        Begin = -1;
        End = -1;
        key = 0;
    }
};
//定义两个边结点的比较函数，用来实现完成最小堆中的排序
struct cmp {
    bool operator()(const EdgeNode a, const EdgeNode b)const {
        //优先比较权重，若权重相同就规定按照起始边排序，我说的
        if (a.key == b.key)
            return a.Begin > b.Begin;
        return a.key > b.key;
    }
};
void Prim(int maze[][100], int size) {
    int newmaze[100][100] = {0};
    //创建最小堆同理
    priority_queue<EdgeNode, vector<EdgeNode>, cmp> minHeap;
    //创建布尔数组用于判断该点是否遍历
    bool* point = new bool [size];

    //初始化
    for (int i = 0; i < size; i++)
        point[i] = false;
    point[0] = true;

    int Count = 1;
    int current = 0;
    EdgeNode newedge;

    //输出空白的邻接矩阵，和算法无关纯属题目要求
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++)
            cout << newmaze[i][j] << " ";
        cout << endl;
    }
    cout << endl;
    //准备就绪开始实现Prim算法，如有不懂可以多多理解课本上的代码
    //睡觉了剩下Prim算法自己看，结合书本理解
    do {
        for (int i = 0; i < size; i++) {
            if (maze[current][i] != 0) {
                if (point[i] == false) {
                    newedge.Begin = current;
                    newedge.End = i;
                    newedge.key = maze[current][i];
                    minHeap.push(newedge);
                }
            }
        }
        while (minHeap.empty() == false && Count < size) {
            newedge = minHeap.top();
            minHeap.pop();
            if (point[newedge.End] == false) {
                newmaze[newedge.Begin][newedge.End] = newedge.key;
                newmaze[newedge.End][newedge.Begin] = newedge.key;
                current = newedge.End;
                point[current] = true;
                Count++;
                for (int i = 0; i < size; i++) {
                    for (int j = 0; j < size; j++)
                        cout << newmaze[i][j] << " ";
                    cout << endl;
                }
                cout << endl;
                break;
            }
        }
    } while (Count < size);
}
//导入邻接矩阵以及矩阵大小
void Kruskal(int maze[][100], int size) {
    int newmaze[100][100] = {0};
    EdgeNode* Alledge = new EdgeNode[1000];
    //用以下操作来记录邻接矩阵中的每一条边，存放在Alledge节点数组中
    int allsize = 0;
    for (int i = 1; i < size; i++)
        for (int j = 0; j < i; j++)
            if (maze[i][j] != 0) {
                Alledge[allsize].Begin = j;
                Alledge[allsize].End = i;
                Alledge[allsize].key = maze[i][j];
                allsize++;
            }

    //创建并查集，并查集的定义在上个板块中
    UFset DSU(size);

    //创建最小堆，里面的cmp比较函数在上面板块中给出
    priority_queue<EdgeNode, vector<EdgeNode>, cmp> minHeap;
    for (int i = 0; i < allsize; i++)
        minHeap.push(Alledge[i]);

    //准备就绪开始实现Kruskal算法，如有不懂可以多多理解课本上的代码

    //输出空白的邻接矩阵，和算法无关纯属题目要求
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++)
            cout << newmaze[i][j] << " ";
        cout << endl;
    }
    cout << endl;

    int Count = 1;
    while (Count < size) {
        //取最小权值边
        EdgeNode minedge = minHeap.top();
        minHeap.pop();
        int a, b, c;
        a = minedge.Begin;
        b = minedge.End;
        c = minedge.key;

        //判断边的两顶点是否在同一个并查集下
        if (!DSU.Same(a, b)) {
            //不是则合并，并连上线输出一次
            DSU.Union(a, b);
            newmaze[a][b] = c;
            newmaze[b][a] = c;
            Count++;
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++)
                    cout << newmaze[i][j] << " ";
                cout << endl;
            }
            cout << endl;
        }
    }
}
//主函数
int main() {
    int n;
    cin >> n;
    int maze[100][100] = {0};
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cin >> maze[i][j];
    cout << "Prim:" << endl;
    Prim(maze, n);
    cout << "Kruskal:" << endl;
    Kruskal(maze, n);

}