VOL.2 拓扑排序与关键路径

拓扑排序与关键路径

对于一个给定的工程施工图，对该图以边为单位从键盘输入，实现拓扑排序算法和关键路径算法，找出并输出该图的关键路径。

要求

图的存储结构采用邻接表存储；
图的顶点和边通过键盘输入；
在屏幕上输出创建的邻接表，每行输出一个顶点的单链表，例如：E： ->G->H
程序运行界面友好，输入要有合理的提示（输入数据的内容以及格式要求）。

测试数据：工程施工图如下：
1.图的存储采用邻接表方式，顶点节点包含四个域：顶点序号域、最早开始时间域、最迟开始时间域、邻接边节点域，边节点包含三个域：顶点序号域、边节点域、权值域。

typedef struct edgeNode {
	int order;
	int weight;
	edgeNode* next_edge;
}edgeNode;

typedef struct vertexNode {
	int order;
	int early_time;
	int late_time;
	edgeNode* next_edge;
}vertexNode;

vertexNode* initialize_vertexNode() {
	// 顶点节点初始化
	vertexNode* vertex_node = (vertexNode*)malloc(sizeof(vertexNode));
	vertex_node->order = INF;
	vertex_node->early_time = 0;
	vertex_node->late_time = INF;
	vertex_node->next_edge = NULL;
	return vertex_node;
}

edgeNode* initialize_edgeNode() {
	// 边节点初始化
	edgeNode* edge_node = (edgeNode*)malloc(sizeof(edgeNode));
	edge_node->weight = INF;
	edge_node->order = INF;
	edge_node->next_edge = NULL;
	return edge_node;
}

2.图的创建要求使用键盘输入，首先由用户输入顶点数量，生成一个n*n的一维动态数组，初始化所有值为INF，a[i * n + j] = x 表示从点i到点j存在边，权值为x。扫描数组创建邻接表，其中INF表示不存在边，不予加入邻接表。

int* initialize_adj_matrix(int vertex_n, int edge_n) {
	// 邻接矩阵创建
	printf("\n");
	int* adj_matrix = (int*)malloc(sizeof(int) * vertex_n * vertex_n);
	for (int i = 0; i < vertex_n * vertex_n; i++) {
		adj_matrix[i] = INF;
	}
	getchar();
	int a, b, c;
	for (int i = 1; i <= edge_n; i++) {
		printf("请输入第%d条边的两个端点（按照相应的顺序）与权值：", i);
		scanf("%d%d%d", &a, &b, &c);
		adj_matrix[a * vertex_n + b] = c;
	}
	return adj_matrix;
}

vertexNode** initialize_vertexs(int* adj_matrix, int lenth) {
	// 邻接矩阵转邻接表
	vertexNode** vertexs = (vertexNode**)malloc(sizeof(vertexNode) * lenth);
	for (int i = 0; i < lenth; i++) {
		edgeNode* edge_node = initialize_edgeNode();
		vertexs[i] = initialize_vertexNode();
		vertexs[i]->order = i;
		vertexs[i]->next_edge = edge_node;
		for (int j = 0; j < lenth; j++) {
			if (adj_matrix[i * lenth + j] < INF) {
				edge_node->order = j;
				edge_node->weight = adj_matrix[i * lenth + j];
				edgeNode* edge_next_node = initialize_edgeNode();
				edge_node->next_edge = edge_next_node;
				edge_node = edge_node->next_edge;
			}
		}
	}
	return vertexs;
}

void print_adj_list(vertexNode** vertexs, int lenth) {
	// 输出邻接表
	printf("\n邻接表如下：\n");
	for (int i = 0; i < lenth; i++) {
		printf("%d: ", vertexs[i]->order);
		edgeNode* edge_node = vertexs[i]->next_edge;
		while (edge_node->order != INF) {
			printf("->%d", edge_node->order);
			edge_node = edge_node->next_edge;
		}
		printf("\n");
	}
}

3.拓扑排序，遍历一次邻接表用一个数组记录每个顶点的前驱节点个数，其中某个顶点被加入拓扑排序序列后，其后继节点的前驱结点个数-1，继续访问前驱结点个数为0的点。用一维数组记录拓扑排序序列。

int* topological_sort(vertexNode** vertexs, int lenth) {
	int* sort_arr = (int*)malloc(sizeof(int) * lenth);
	int* count_arr = (int*)malloc(sizeof(int) * lenth);
	for (int i = 0; i < lenth; i++) {
		sort_arr[i] = 0;
		count_arr[i] = 0;
	}
	for (int i = 0; i < lenth; i++) {
		edgeNode* edge_node = vertexs[i]->next_edge;
		while (edge_node->order != INF) {
			count_arr[edge_node->order]++;
			edge_node = edge_node->next_edge;
		}
	}
	for (int i = 0; i < lenth; i++) {
		int order;
		for (int j = 0; j < lenth; j++) {
			if (count_arr[j] == 0) {
				order = j;
				break;
			}
		}
		sort_arr[i] = order;
		count_arr[order] = -1;
		edgeNode* edge_node = vertexs[order]->next_edge;
		while (edge_node->order != INF) {
			count_arr[edge_node->order]--;
			edge_node = edge_node->next_edge;
		}
	}
	printf("\n拓扑排序顺序为：");
	for (int i = 0; i < lenth; i++) {
		printf("%d", sort_arr[i]);
	}
	printf("\n");
	return sort_arr;
}

4.完成拓扑排序后，按照拓扑排序的顺序依次访问顶点节点，修改顶点的early_time域，每个节点的early_time域在初始化时置为0。对每条边进行操作时，当前边的起点节点early_time、边权值的和与当前边的终点节点的early_time进行比较，若前者大，则进行修改，遍历所有的边后完成每个节点early_time的处理。再按照拓扑排序的逆序列依次访问顶点节点，修改顶点节点的late_time域，每个节点的late_time域在初始化时置为INF。其中，汇点的late_time等于early_time直接进行修改不需要进行比较，也不需要进行访问。对每条边进行操作时，当前边的起点节点late_time域与当前边的终点节点late_time、边权值的差进行比较，若后者小，则进行修改，遍历所有边后完成每个节点late_time的处理。修改完后，通过顶点节点数组按照边的顺序遍历并打印所有early_time与late_time相等的顶点即关键活动，继而求得关键路径。

void get_critical_paths(int* sort_arr, vertexNode** vertexs, int lenth, int start_order, int end_order) {
	edgeNode* edge_node;
	for (int i = 0; i < lenth; i++) {
		edge_node = vertexs[i]->next_edge;
		while (edge_node->order != INF) {
			if (vertexs[i]->early_time + edge_node->weight > vertexs[edge_node->order]->early_time)
				vertexs[edge_node->order]->early_time = vertexs[i]->early_time + edge_node->weight;
			edge_node = edge_node->next_edge;
		}
	}
	vertexs[lenth - 1]->late_time = vertexs[lenth - 1]->early_time;
	for (int i = lenth - 2; i >= 0; i--) {
		edge_node = vertexs[i]->next_edge;
		while (edge_node->order != INF) {
			if (vertexs[i]->late_time > vertexs[edge_node->order]->late_time - edge_node->weight)
				vertexs[i]->late_time = vertexs[edge_node->order]->late_time - edge_node->weight;
			edge_node = edge_node->next_edge;
		}
	}
	int* critical_paths = (int*)malloc(sizeof(int) * lenth);
	critical_paths[0] = start_order;
	int order = 1;
	while (1) {
		if (critical_paths[order - 1] == end_order) break;
		edge_node = vertexs[critical_paths[order - 1]]->next_edge;
		while (1) {
			if (vertexs[edge_node->order]->early_time == vertexs[edge_node->order]->late_time) {
				critical_paths[order] = edge_node->order;
				order++;
				break;
			}
			else edge_node = edge_node->next_edge;
		}
	}
	printf("\n关键路径为：");
	printf("%d", critical_paths[0]);
	for (int i = 1; i < order; i++) {
		printf("->%d", critical_paths[i]);
	}
}

最终效果：

问题与总结：吸取了上一次的教训，把每个用到的结构体节点以及数组仔细进行了初始化，在这次代码编写过程中，没有出现任何内存访问冲突的问题！并且解决了上一次没有解决的邻接表顶点节点用数组存储的问题，大大简化了代码复杂程度也提高了可读性！