最小生成输出Kruskal算法 C

#include<stdio.h>
#include<stdlib.h>
#define MAX 999999
typedef struct Graph {
	char* vexs;
	int** arcs;
	int vexNum;
	int arcNum;
}Graph;
typedef struct Edge {
	char start;
	char end;
	int weight;
}Edge;

Edge* initEdge(Graph*G) {
	int index = 0;
	Edge* E = (Edge*)malloc(sizeof(Edge) * G->arcNum);
	for (int i = 0; i < G->vexNum; i++)
	{
		for (int j = i+1; j < G->vexNum; j++)
		{
			if (G->arcs[i][j]!=MAX)
			{
				E[index].start = i;
				E[index].end = j;
				E[index].weight = G->arcs[i][j];
				index++;
			}
			
		}
	}
	return E;
}
void sortEdge(Edge* edge, Graph* G) {
	Edge temp;
	for (int i = 0; i < G->arcNum - 1; i++) {
		for (int j = 0; j < G->arcNum - i - 1; j++) {
			if (edge[j].weight > edge[j + 1].weight) {
				temp = edge[j];
				edge[j] = edge[j + 1];
				edge[j + 1] = temp;
			}
		}
	}
}

void kruskal(Graph*G) {
	int* pre = (int*)malloc(sizeof(int) * G->vexNum);
	for (int i = 0; i < G->vexNum; i++)
	{
		pre[i] = i;
	}
	Edge* E = initEdge(G);
	sortEdge(E, G);
	for (int i = 0; i < G->arcNum; i++)
	{
		int strat_pre = pre[E[i].start];
		int end_pre = pre[E[i].end];
		if (strat_pre!=end_pre)
		{
			printf("V%c-->V%c,weight==%d\n", G->vexs[E[i].start], G->vexs[E[i].end], E[i].weight);
			for (int j = 0; j < G->vexNum; j++)
			{
				if (pre[j]==end_pre)
				{
					pre[j] = strat_pre;
				}
			}
		}

	}

}
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 ", 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");
	kruskal(G);
	return 0;
}

 参考：

分类: Data Structure | tyrantlucifer