最小生成树Prim算法 C

#include<stdio.h>
#include<stdlib.h>
#define MAX 99999
typedef struct Graph {
    char* vexs;
    int** arcs;
    int vexNum;
    int arcNum;
}Graph;
typedef struct Edge {
    char vex;
    int weight;
}Edge;
Edge* initEdge(Graph*G,int index) {
    Edge* E = (Edge*)malloc(sizeof(Edge)*G->vexNum);
    for (int i = 0; i < G->vexNum; i++)
    {
        E[i].vex = G->vexs[index];
        E[i].weight = G->arcs[index][i];
    }
    return E;
}
int getmin(Graph*G,Edge*E){
    int get;
    int min = MAX;
    for (int i = 0; i < G->vexNum; i++)
    {
        if (E[i].weight!=0&&E[i].weight<min)
        {
            min = E[i].weight;
            get = i;
        }
    }
    return get;
}
void prim(Graph*G,int index) {
    int min;
    Edge* E = initEdge(G, index);
    for (int i = 0; i < G->vexNum-1; i++)
    {
        min = getmin(G, E);
        printf("V%c-->V%c,weight==%d\n", E[min].vex, G->vexs[min], E[min].weight);
        E[min].weight = 0;
        for (int j = 0; j < G->vexNum; j++)
        {
            if (E[j].weight>G->arcs[min][j])
            {
                E[j].weight = G->arcs[min][j];
                E[j].vex = G->vexs[min];
            }
        }
    }
}
Graph* initGraph(int vexNum) {
    Graph* G = (Graph*)malloc(sizeof(Graph));
    G->vexs = (char*)malloc(sizeof(char) * vexNum);
    G->arcs = (int**)malloc(sizeof(int*) * vexNum);
    for (int i = 0; i < vexNum; i++)
    {
        G->arcs[i] = (int*)malloc(sizeof(int)*vexNum);
    }
    G->vexNum = vexNum;
    G->arcNum = 0;
    return G;
}
void createGraph(Graph*G,char*vexs,int*data) {
    for (int i = 0; i < G->vexNum; i++)
    {
        G->vexs[i] = vexs[i];
        for (int j = 0; j < G->vexNum; j++)
        {
            G->arcs[i][j] = *(data + i * G->vexNum + j);
            if (G->arcs[i][j]!=0&&G->arcs[i][j]!=MAX)
            {
                G->arcNum++;
            }
        }
    }
    G->arcNum /= 2;  
}
void DFS(Graph* G,int *visited,int index ){
    printf("%c\t", G->vexs[index]);
    visited[index] = 1;
    for (int i = 0; i < G->vexNum; i++)
    {
        if (G->arcs[index][i]>0&&G->arcs[index][i]!=MAX&&!visited[i])
        {
            DFS(G, visited, i);
        }
    }
    
}
int main() {
    Graph* G = initGraph(6);
    int* visited = (int*)malloc(sizeof(int) * G->vexNum);
    for (int i = 0; i < G->vexNum; i++)
        visited[i] = 0;
    int arcs[6][6] = {
        0, 6, 1, 5, MAX, MAX,
        6, 0, 5, MAX, 3, MAX,
        1, 5, 0, 5, 6, 4,
        5, MAX, 5, 0, MAX, 2,
        MAX, 3, 6, MAX, 0, 6,
        MAX, MAX, 4, 2, 6, 0
    };
    createGraph(G, "123456", (int*)arcs);
    DFS(G, visited, 0);
    printf("\n");
    prim(G, 0);
    return 0;
}

 参考：

分类: Data Structure | tyrantlucifer