普里姆算法

普里姆算法---最小生成树

代码中的数据如图所示

coding

//普里姆算法 
///*
// * 图顶点之前不通，那么邻接矩阵的值为MAX
// * 如果顶点是自己本身，那么值为0
// */


#include <stdio.h>
#include <stdlib.h>
#define MAX 32767

typedef struct Graph {
    char* vexs;	//图顶点 
    int** arcs;	//图的边 
    int vexNum;	//顶点数 
    int arcNum;	//边数 
}Graph;

typedef struct Edge {
    char vex;	//顶点 
    int weight;	//边的权值 
}Edge;


Edge* initEdeg(Graph* G) {	 
    int index = 0;        //index最初始的那个顶点数
    Edge* edge = (Edge*)malloc(sizeof(Edge) * G -> vexNum);
    for (int i = 0; i < G -> vexNum; i++) {
        edge[i].vex = G -> vexs[index]; //将index的顶点加入到集合中 
        edge[i].weight = G -> arcs[index][i];	//将index的边加入到集合中 
    }
    return edge;
}

//获取权值最小的顶点 
int getMinEdge(Edge* edge, Graph* G) {
    int index;
    int min = MAX;
    for (int i = 0; i < G -> vexNum; i++) {
        if (edge[i].weight != 0 && min > edge[i].weight) {
            min = edge[i].weight;
            index = i;
        }
    }
    return index;
}

//普里姆算法 
void prim(Graph* G) {
    int min;
    int index = 0;
    Edge* edge = initEdeg(G);
    
    for (int i = 0; i < G -> vexNum - 1; i++) {
        min = getMinEdge(edge, G);	//获取权值最小的边 
        printf("v%c --> v%c, weight = %d\n", edge[min].vex, G -> vexs[min], edge[min].weight);	//输出路径 
        edge[min].weight = 0;	//把该点权值设为0，代表已经加入到U集合中 
        
        //更新数组中到某个顶点的最小边 
        for (int j = 0; j < G -> vexNum; j++) {
            if (G -> arcs[min][j] < edge[j].weight) {//如果新加入进来的顶点的边权值有小于当前顶点权值的就更新 
                edge[j].weight = G -> arcs[min][j];	//更新权值 
                edge[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* arcs) {
    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] = *(arcs + 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,3,MAX,MAX,
		6,0,6,MAX,MAX,5,
		1,6,0,6,5,4,
		3,MAX,6,0,6,MAX,
		MAX,MAX,5,6,0,3,
		MAX,5,4,MAX,3,0

    };
    createGraph(G, "123456", *arcs);
    DFS(G, visited, 0);
    printf("\n");
    prim(G);
    return 0;
}