邻接矩阵存储 - Prim最小生成树算法

邻接表存储最小生成树：

关于定义无穷为0x3f3f3f3f的原因，点击这里！

#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 1010

using namespace std;

int dist[MAX];
int parent[MAX];//存储当前节点的父节点

typedef struct ENode
{
    int V1, V2;
    int Weight;
}*Edge;

//邻接矩阵
typedef struct GNode
{
    int Vertex_num;
    int EdgeNum;
    int G[MAX][MAX];
}*Graph;

struct AdjNode
{
    int Adj;
    AdjNode *Next;
    int Weight;
};

typedef struct VNode
{
    AdjNode *First;
    int Data;
}*AdjList[MAX];

//邻接表
typedef struct LGNode
{
    int Vertex_num;
    int EdgeNum;
    AdjList G;
}*LGraph;

Graph InitGraph(int VertexNum)
{
    Graph G =(Graph)malloc(sizeof(GNode));
    G->Vertex_num = VertexNum;
    G->EdgeNum = 0;
    //邻接矩阵初始化
    memset(G->G, 0x3f, sizeof(G->G));
    return G;
}

LGraph InitLGraph(int VertexNum)
{
    LGraph G;

    G = (LGraph)malloc(sizeof(LGNode));
    G->Vertex_num = VertexNum;
    G->EdgeNum = 0;
    for(int i = 0; i < G->Vertex_num; i++)
        G->G[i]->First = NULL;

    return G;
}

void InsertLGEdge(LGraph G, Edge E)
{
    AdjNode *NewNode;
    //为V2建立邻接点
    NewNode = (AdjNode*)malloc(sizeof(AdjNode));
    NewNode->Adj = E->V2;
    NewNode->Weight = E->Weight;
    //将V2插入V1的表头------头插法
    NewNode->Next = G->G[E->V1]->First;
    G->G[E->V1]->First = NewNode;
}

void InsertGEdge(Graph G, Edge E)
{
    G->G[E->V1][E->V2] = E->Weight;
    G->G[E->V2][E->V1] = E->Weight;
}

Graph BuildGraph()
{
    Graph G;
    Edge E;
    int VertexNum;
    cin >> VertexNum;
    G = InitGraph(VertexNum);
    cin >> G->EdgeNum;

    if(G->EdgeNum == 0) return G;

    E = (Edge)malloc(sizeof(ENode));
    for(int i = 0; i < G->EdgeNum; i++)
    {
        cin >> E->V1 >> E->V2 >> E->Weight;
        InsertGEdge(G, E);
    }
    return G;
}

LGraph BuildLGraph(int VertexNum)
{
    LGraph G;
    Edge E;
    G = InitLGraph(VertexNum);
    cin >> G->EdgeNum;

    if(G->EdgeNum == 0) return G;

    E = (Edge)malloc(sizeof(ENode));
    for(int i = 0; i < G->EdgeNum; i++)
    {
        cin >> E->V1 >> E->V2 >> E->Weight;
        InsertLGEdge(G, E);
    }
    return G;
}

/* 邻接矩阵存储 - Prim最小生成树算法 */

int FindMinDist(Graph G)
{
    //默认MinV为-1，没有找到直接返回-1
    int MinDist = INF, MinV = -1;
    for(int V = 0; V < G->Vertex_num; V++)
    {
        if(dist[V] != 0 && dist[V] < MinDist)
        {
            MinDist = dist[V];
            MinV = V;
        }
    }
    return MinV;
}

int Prim(Graph G, LGraph MST, int S)
{
    int V;
    int VNum = 0;       //收入最小生成树的个数
    int TotalWeight = 0;//最小权重
    Edge E;

    for(int i = 0; i < G->Vertex_num; i++)
    {
        dist[i] = G->G[S][i];
        //全部初始化为初始点S
        parent[i] = S;
    }
    E = (Edge)malloc(sizeof(ENode));
    MST = (LGraph)malloc(sizeof(LGNode));
    MST = BuildLGraph(G->Vertex_num);

    //将初始点收录MST
    dist[S] = 0;
    VNum++;
    parent[S] = -1;

    while(1)
    {
        V = FindMinDist(G);
        //若找不到，退出
        if(V == -1) break;

        //将最小边插入MST
        E->V1 = parent[V];
        E->V2 = V;
        E->Weight = dist[V];
        InsertLGEdge(MST, E);
        //累计权重和
        TotalWeight += dist[V];
        //收入MST则将其距离置为0
        dist[V] = 0;
        //累计收入顶点数
        VNum++;
        for(int W = 0; W < G->Vertex_num; W++)
        {
            //若没有被收录，并且是V的邻接点
            if(dist[W] != 0 && G->G[V][W] < INF)
            {
                //若邻接点的距离更小于初始值，更新
                if(G->G[V][W] < dist[W])
                {
                	dist[W] = G->G[V][W];
                	//记录路径
                	parent[W] = V;
                }   
            }
        }
    }

    //若结束后顶点数没有全收录，则说明不是连通图，将权重置为-1
    if(VNum < G->Vertex_num) TotalWeight = -1;
    //返回权重和
    return TotalWeight;
}

int main()
{

    return 0;
}