数据结构课程设计 拓扑排序+关键路径+可视化界面

已于 2025-02-01 15:01:24 修改
阅读量299 收藏 4
点赞数 5
文章标签： 数据结构
于 2025-02-01 14:58:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80389709/article/details/145412522
版权

1.问题背景

   本课程设计中旨在构建一个项目工期成本分析程序，该程序的核心功能是解析和处理项目活动数据。这些数据包括但不限于活动编号、名称、正常完成所需天数、加班完成所需天数、加班费用、前驱活动编号以及后驱活动编号。程序将从文本文件中读取至少20个活动的数据，以确保分析的全面性和实用性。通过这一过程，程序将能够计算并输出在正常工作条件下完成项目所需的总天数，以及在考虑加班情况下完成项目所需的总天数和由此产生的额外加班费用。

2.主要运行界面

2.1菜单页面

界面顶部有一个标题 “项目工期分析”，明确了软件的主要功能。界面中央有四个功能选项，分别是：（1）工期查询（2）时间对照（3）甘特图显示（4）关键路径

图4.1 项目工期分析菜单界面

   4.1.2 点击“工期查询”后  

   如图所示，点击工期查询，便会让用户输入想要查询的节点（如图4.3）。

        

图4.2 工期查询菜单界面

图4.3 查询节点菜单界面

点击确定后便会输出距离最早最晚完工时间（如图4.4）

图4.4 查询节点距离完工时间的界面

4.1.3 点击“时间对照”后

所有节点最早和最晚的开始时间，并将最早时间等于最晚时间的节点进行标红处理。这些节点为关键路径上的点。

图4.5 查询所有节点最早最晚时间的界面

4.1.4 点击“工期查询”后  

   如图所示，点击甘特图显示，便会出现这张用project画出来的甘特图（如图4.6）。

图4.6 显示甘特图的界面

4.1.5 点击“关键路径”后  

   如图所示，点击关键路径后，也会出现想要查询的节点（如图4.7）。输入节点后，会出现弹窗显示是否为关键节点（如图4.8与4.9）。

图4.7 显示想要查询节点的界面

图4.8 是关键节点的界面

图4.9 不是关键节点的界面

若为关键节点（图4.8），则会弹出图4.10的界面，输出加班成本和加班后需要天数。

图4.10 显示节点加班成本和天数的界面

然后，会弹出一张带有所有节点的路径图，显示出关键路径（标红部分），让用户可以进行更仔细地分析。

图4.11 显示完整路径图的界面

完整代码：

#define _CRT_SECURE_NO_WARNINGS //一些老函数报错
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h> //Easyx的图形库头文件
#include<string.h>
#include<ctype.h>//检测字符

int flag = 0;//全局变量，用来判断是否有关键路径
int* t, * ve, * vl;   //t:记录拓扑序列结果，ve:最早开始时间，vl:最迟开始时间 
typedef struct arc/*边表节点*/
{
	int index; //编号 
	int weight; //正常工作时间
	int plusweight;//加班完成时间
	int cost; //加班费用
	struct arc* next; //指向下一个节点 
}AR;

typedef struct MyGraph
{
	int type;//0表示无向网，1表示有向网
	int arcnum; //边的数量 
	int vexnum;  //点的个数 
	char** vexname; //点的名字 
	AR* N;//邻接表 
}GH;
GH G;
int findVertexIndex(GH* G, char* s);//确定顶点s对应的编号号
void creatgraph(GH* G);//以邻接表的形式创建图
void printgraph(GH* G);//以邻接表的形式显示图
int topologicalsort(GH* G, int* t);//获得拓扑排序
void keypath(GH* G);   //获得关键路径
void allkeypath(GH* G, int head, int end, int* path, int n, int length, int* visit, int* isequl);//显示所有关键路径(不止一条)
void show1();
void show2();
void show3();
void show4();
int chainitAndAnalyze();
int findNode();
void initAndAnalyze();
void PrintUI();


//定义按钮的大小数组
int R[] = { 150,50,650,150 };
int r1[] = { 200,340,600,390 };
int r2[] = { 200,410,600,460 };
int r3[] = { 200,480,600,530 };
int r6[] = { 200,270,600,320 };
void initAndAnalyze()
{
	printf("\n--------------项目成本分析课程设计--------------\n\n");  //说明该代码的实现功能 
	printf("\n原图为：\n");
	creatgraph(&G);//创建图
	printgraph(&G);//显示图
	keypath(&G);
}

int findVertexIndex(GH* G, char* s)
{
	int i;
	for (i = 0; i < G->vexnum; i++)
	{
		if (strcmp(G->vexname[i], s) == 0)//判断字符串是否一样 
			return i;
	}
	printf("Error!\n");
	exit(0);
}

void creatgraph(GH* G)
{
	FILE* fp;
	int i, j, n;
	int k, l, m;//记录权重 
	char s1[20], s2[20];
	AR* p;
	errno_t err = fopen_s(&fp, "D:\\课设\\数据结构课设数据.txt", "r");
	//"D:\\课设\\有回路.txt"
	//"D:\\课设\\数据结构课设数据.txt"
	if (err != 0 || !fp) {
		printf("Can not open file!!!\n");
		exit(0);
	}
	fscanf_s(fp, "%d", &n);
	G->vexnum = n; //点的数量 
	G->type = 1;  //有向图 
	G->N = (AR*)malloc(n * sizeof(AR));
	G->vexname = (char**)malloc(n * sizeof(char*));
	G->arcnum = 0; //边的数量初始化为0 
	for (i = 0; i < n; i++)//初始化 
	{
		fscanf_s(fp, "%s", s1, sizeof(s1));
		G->vexname[i] = (char*)malloc(strlen(s1) + 1);
		strcpy_s(G->vexname[i], strlen(s1) + 1, s1);
		G->N[i].next = NULL;
	}
	while (fscanf_s(fp, "%19s %19s %d %d %d", s1, (unsigned)_countof(s1), s2, (unsigned)_countof(s2), &k, &l, &m) != EOF)//读入边的两个顶点和权重
	{
		p = (AR*)malloc(sizeof(AR));
		i = findVertexIndex(G, s1);
		j = findVertexIndex(G, s2);
		(G->arcnum)++;
		p->index = j;
		p->weight = k;
		p->plusweight = l;
		p->cost = m;
		p->next = G->N[i].next;
		G->N[i].next = p;
	}
	fclose(fp);//关闭文件	
}

void printgraph(GH* G)//用邻接表显示图 
{
	int i;
	AR* p;
	for (i = 0; i < G->vexnum; i++)
	{
		printf("\n%s", G->vexname[i]);
		p = G->N[i].next;
		while (p)
		{
			printf("--->%s", G->vexname[p->index]);
			p = p->next;
		}
		printf("\n");
	}
	printf("\n");
}

int topologicalsort(GH* G, int* t)
{
	int* stack, * indegree;//stack是栈，将入度为0的点入栈,indegree是记录每个点入度的数组,用来寻找入度为0的点 
	int top = -1, count = 0, i;//top为栈顶，count表示 
	AR* p;
	stack = (int*)malloc(G->vexnum * sizeof(int));
	indegree = (int*)malloc(G->vexnum * sizeof(int));
	memset(indegree, 0, G->vexnum * sizeof(int));//初始化,将所有点的入度初始化为0
	for (i = 0; i < G->vexnum; i++)//求每个点的入度
	{
		p = G->N[i].next;
		while (p)
		{
			indegree[p->index]++;
			p = p->next;
		}
	}
	for (i = 0; i < G->vexnum; i++)//将入度为0的点入栈 
	{
		if (indegree[i] == 0)
		{
			top++;
			stack[top] = i;
		}
	}
	while (top >= 0)
	{
		i = stack[top];
		top--;
		t[count] = i;
		count++;
		p = G->N[i].next;
		while (p)//将所有该点连接的点的入度都减一 
		{
			indegree[p->index]--;
			if (indegree[p->index] == 0)//发现减完后，有点入度为0，入栈 
			{
				top++;
				stack[top] = p->index;
			}
			p = p->next;
		}
	}
	free(stack);
	free(indegree);
	if (count == G->vexnum)//判断是否所有点都在拓扑排序里面，是的话返回1，否则因为没有所有点进入排序，说明排序失败：返回0 
		return 1;
	else
		return 0;
}

void keypath(GH* G)
{
	int* visit, * path, * isequl;//visit记录每个点是否被访问，path记录路径上的点，isequl记录每个点最早开始时间和最迟是否相等，1代表相等，0代表不等 
	int i;
	int max;//用来寻找最早开始时间的最大值 
	AR* p;
	t = (int*)malloc(G->vexnum * sizeof(int));
	ve = (int*)malloc(G->vexnum * sizeof(int));
	vl = (int*)malloc(G->vexnum * sizeof(int));
	visit = (int*)malloc(G->vexnum * sizeof(int));
	path = (int*)malloc(G->vexnum * sizeof(int));
	isequl = (int*)malloc(G->vexnum * sizeof(int));

	memset(ve, 0, G->vexnum * sizeof(int));//初始化，将所有点的最早开始时间初始化为0
	memset(visit, 0, G->vexnum * sizeof(int)); //初始化，将所有点的访问状态初始化为未访问
	memset(vl, 0, G->vexnum * sizeof(int));//初始化，将所有点的最迟开始时间初始化为0
	memset(isequl, 0, G->vexnum * sizeof(int));
	if (!topologicalsort(G, t))//拓扑排序并输出拓扑序列 
	{
		printf("图中有回路，不存在关键路径!\n");
		exit(0);
	}
	for (i = 0; i < G->vexnum; i++)//求每个点的最早开始时间并输出,从前往后 
	{
		p = G->N[t[i]].next;// 获取拓扑排序中第i个顶点的所有邻接点链表的头结点
		while (p)
		{
			if (ve[p->index] < (ve[t[i]] + p->weight))//判断更新最小的时间，ve[p->index] 是邻接点的当前最早开始时间，ve[t[i]] + p->weight 是通过当前顶点到邻接点的边计算出的最早开始时间。 
				ve[p->index] = ve[t[i]] + p->weight;
			p = p->next;
		}
	}
	printf("\n最早发生时间:\n");
	max = ve[0];// 初始化最大值为第一个顶点的最早开始时间
	for (i = 0; i < G->vexnum; i++)
	{
		if (ve[i] > max)
			max = ve[i];
		printf("%s: %d\n", G->vexname[i], ve[i]);
	}
	printf("\n");
	for (i = 0; i < G->vexnum; i++)//给每个点的最迟开始时间赋初值,为最早开始时间 
		vl[i] = max;
	for (i = G->vexnum - 1; i >= 0; i--)//求每个点的最迟开始时间并输出 
	{
		p = G->N[t[i]].next;// 获取当前顶点的所有邻接点链表的头结点
		while (p)
		{
			if (vl[t[i]] > (vl[p->index] - p->weight))//思路同上，vl[t[i]] 是邻接点的当前最迟开始时间，vl[p->index] - p->weight 是通过当前顶点到邻接点的边计算出的最迟开始时间。
				vl[t[i]] = vl[p->index] - p->weight;
			p = p->next;
		}
	}
	printf("最迟发生时间:\n");
	for (i = 0; i < G->vexnum; i++)
	{
		printf("%s: %d\n", G->vexname[i], vl[i]);
		if (vl[i] == ve[i])//将最早开始时间和最迟开始时间相等的点的isequal记为1，寻找关键路径 
			isequl[i] = 1;
	}
	printf("\n");
	path[0] = t[0];
	allkeypath(G, t[0], t[G->vexnum - 1], path, 1, 0, visit, isequl);//递归调用allkeypath函数显示所有关键路径 
}

void allkeypath(GH* G, int head, int end, int* path, int n, int length, int* visit, int* isequl)//path用来存储路径，这个仿照了之前迷宫的路径输出方式 
{
	if (head == end)//到达终点 
	{
		int i;
		flag++;//全局变量flag用来记录关键路径的数量
		printf("关键路径：");
		for (i = 0; i < n - 1; i++)
			printf("%s-->", G->vexname[path[i]]);
		printf("%s   路径长度为：%d\n\n", G->vexname[path[i]], length);
	}
	else
	{
		AR* p;
		p = G->N[head].next;
		while (p)//遍历每个点的所有后继 
		{
			if (!visit[p->index] && isequl[p->index])
			{
				path[n] = p->index;
				visit[p->index] = 1;
				allkeypath(G, p->index, end, path, n + 1, length + p->weight, visit, isequl);//递归调用自己，显示所有关键路径 
				visit[p->index] = 0;//回溯
			}
			p = p->next; 移动到下一个后继顶点
		}
	}
}

//主菜单
void menu()
{
	//进入程序就读取数据，获取当前nowstu_num
	initAndAnalyze();
	initgraph(800, 620);//界面大小

	//鼠标操作1
	ExMessage m1;
	cleardevice();

	//背景图
	IMAGE img; // 定义一个 IMAGE 结构体来存储图像数据
	loadimage(&img, "D:\\课设\\最新调试\\res\\背景.jpg"); // 加载图像
	putimage(0, 0, &img); // 将图像绘制在窗口的 (0, 0) 位置


	setbkmode(TRANSPARENT);
	setfillcolor(WHITE);
	fillrectangle(r1[0], r1[1], r1[2], r1[3]);//按钮
	fillrectangle(r2[0], r2[1], r2[2], r2[3]);
	fillrectangle(r3[0], r3[1], r3[2], r3[3]);
	fillrectangle(r6[0], r6[1], r6[2], r6[3]);


	RECT R1 = { R[0],R[1],R[2],R[3] };//矩形指针R1，方便后面在里面写字，不用计算字的位置
	RECT R4 = { r1[0],r1[1],r1[2],r1[3] };
	RECT R5 = { r2[0],r2[1],r2[2],r2[3] };
	RECT R6 = { r3[0],r3[1],r3[2],r3[3] };
	RECT R7 = { r6[0],r6[1],r6[2],r6[3] };

	LOGFONT f;                          //字体样式指针
	gettextstyle(&f);					//获取字体样式
	f.lfHeight = 60;
	_tcscpy(f.lfFaceName, _T("宋体"));	//宋体
	f.lfQuality = ANTIALIASED_QUALITY;  // 抗锯齿 
	settextstyle(&f);                   // 设置字体样式
	setbkmode(TRANSPARENT);             //字体背景透明
	settextcolor(BLACK);
	drawtext("项目工期分析", &R1, DT_CENTER | DT_VCENTER | DT_SINGLELINE);//在矩形区域R1内输入文字，水平居中，垂直居中，单行显示
	drawtext("时间对照", &R4, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	drawtext("甘特图显示", &R5, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	drawtext("关键路径", &R6, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	drawtext("工期查询", &R7, DT_CENTER | DT_VCENTER | DT_SINGLELINE);


	//进入主界面选项操作界面
	while (1)
	{
		m1 = getmessage();//获取鼠标操作
		if (m1.x > r1[0] && m1.x < r1[2] && m1.y>r1[1] && m1.y < r1[3]) {
			setlinecolor(RED);
			rectangle(r1[0], r1[1], r1[2], r1[3]);
			if (m1.message == WM_LBUTTONDOWN)
			{
				show1();//打印时间
			}
		}
		else if (m1.x >= r2[0] && m1.x <= r2[2] && m1.y >= r2[1] && m1.y <= r2[3]) {
			setlinecolor(RED);
			rectangle(r2[0], r2[1], r2[2], r2[3]);
			if (m1.message == WM_LBUTTONDOWN)
			{
				show2();
			}
		}
		else if (m1.x >= r3[0] && m1.x <= r3[2] && m1.y >= r3[1] && m1.y <= r3[3]) {
			setlinecolor(RED);
			rectangle(r3[0], r3[1], r3[2], r3[3]);
			if (m1.message == WM_LBUTTONDOWN)
			{
				show3();//修改
			}
		}
		else if (m1.x >= r6[0] && m1.x <= r6[2] && m1.y >= r6[1] && m1.y <= r6[3]) {
			setlinecolor(RED);
			rectangle(r6[0], r6[1], r6[2], r6[3]);
			if (m1.message == WM_LBUTTONDOWN)
			{
				show4();//修改
			}
		}
		else {
			setlinecolor(WHITE);
			rectangle(r1[0], r1[1], r1[2], r1[3]);
			rectangle(r2[0], r2[1], r2[2], r2[3]);
			rectangle(r3[0], r3[1], r3[2], r3[3]);
			rectangle(r6[0], r6[1], r6[2], r6[3]);
		}
	}

}



void show1() //打印时间
{
	ExMessage m3;
	initgraph(800, 620);
	IMAGE img2;
	loadimage(&img2, "D:\\课设\\最新调试\\res\\背景.jpg", 800, 620);
	putimage(0, 0, &img2);
	setfillcolor(WHITE);
	fillrectangle(680, 490, 760, 520);
	setbkmode(TRANSPARENT);
	settextcolor(BLACK);

	settextstyle(20, 0, "黑体");
	outtextxy(40, 20, "名称");
	outtextxy(200, 20, "最早时间");
	outtextxy(300, 20, "最晚时间");
	outtextxy(700, 500, "返回");//返回按钮

	char ve_str[20];
	char vl_str[20];
	for (int q = 0; q < G.vexnum; q++) {
		sprintf(ve_str, "%d", ve[q]);
		sprintf(vl_str, "%d", vl[q]);

		// 根据ve_str和vl_str是否相等来设置不同的文本颜色
		if (strcmp(ve_str, vl_str) == 0) {
			settextcolor(RED);
		}
		else {
			settextcolor(BLACK);
		}
		outtextxy(40, 60 + q * 20, G.vexname[q]);
		outtextxy(200, 60 + q * 20, ve_str);
		outtextxy(300, 60 + q * 20, vl_str);

		// 输出完当前这组数据后，将文本颜色恢复为默认的黑色（如果后续有其他需要统一颜色的情况）
		settextcolor(BLACK);
	}


	while (1) {
		m3 = getmessage();
		if (m3.x > 680 && m3.x < 760 && m3.y > 490 && m3.y < 520) {
			setlinecolor(RED);
			rectangle(680, 490, 760, 520);
		}
		else {
			setlinecolor(WHITE);
			rectangle(680, 490, 760, 520);
		}
		if (m3.message == WM_LBUTTONDOWN) {
			menu();//返回主菜单
		}
	}
}
void show2() //打印时间
{
	ExMessage m4;
	initgraph(800, 620);
	IMAGE img3;
	loadimage(&img3, "D:\\课设\\res\\屏幕截图 2024-12-20 234937.jpg", 800, 620);
	putimage(0, 0, &img3);
	fillrectangle(680, 490, 760, 520);

	outtextxy(700, 500, "返回");//返回按钮



	while (1) {
		m4 = getmessage();
		if (m4.x > 680 && m4.x < 760 && m4.y > 490 && m4.y < 520) {
			setlinecolor(RED);
			rectangle(680, 490, 760, 520);
		}
		else {
			setlinecolor(WHITE);
			rectangle(680, 490, 760, 520);
		}
		if (m4.message == WM_LBUTTONDOWN) {
			menu();//返回主菜单
		}
	}

}
void show3() //打印时间
{
	int fan1 = findNode();//返回值
	if (fan1 == -1)//没找到
	{
		//获取窗口句柄
		HWND hndtipsF = GetHWnd();
		int isok = MessageBox(hndtipsF, "查无此节点!", "提示", MB_OK);
	}
	else
	{
		if (ve[fan1] == vl[fan1])//判断是否为关键节点
		{
			// 先弹出是否为关键节点的提示框
			HWND hndtipsF = GetHWnd();
			int isok = MessageBox(hndtipsF, "此节点为关键节点，加班可以缩短工期!", "提示", MB_OK);

			// 获取关键节点的cost和plusweight信息
			AR* p = G.N[fan1].next;
			if (p != NULL)  // 确保存在出边
			{
				int costOfCriticalNode = p->cost;
				int plusweightOfCriticalNode = p->plusweight;

				// 显示关键节点信息的单独白框界面
				ExMessage m4;
				initgraph(800, 620);
				setbkcolor(WHITE);  // 设置背景颜色为白色
				cleardevice();      // 清屏使背景生效

				setbkmode(TRANSPARENT);
				settextcolor(BLACK);
				settextstyle(20, 0, "黑体");

				// 输出关键节点的cost信息
				char cost_str[20];
				sprintf(cost_str, "关键节点加班成本: %d", costOfCriticalNode);
				outtextxy(40, 140, cost_str);

				// 输出关键节点的加班天数信息
				char plusweight_str[20];
				sprintf(plusweight_str, "关键节点加班天数: %d", plusweightOfCriticalNode);
				outtextxy(40, 180, plusweight_str);

				fillrectangle(680, 490, 760, 520);
				outtextxy(700, 500, "返回");// 返回按钮，提示可查看详情

				while (1)
				{
					m4 = getmessage();
					if (m4.x > 680 && m4.x < 760 && m4.y > 490 && m4.y < 520)
					{
						setlinecolor(RED);
						rectangle(680, 490, 760, 520);
					}
					else
					{
						setlinecolor(WHITE);
						rectangle(680, 490, 760, 520);
					}
					if (m4.message == WM_LBUTTONDOWN)
					{
						// 点击“返回（查看详情）”按钮后，进入下一阶段，显示图片界面
						initgraph(800, 620);
						IMAGE img3;
						loadimage(&img3, "D:\\课设\\游戏\\游戏\\路线图.jpg", 800, 620);
						putimage(0, 0, &img3);
						fillrectangle(680, 490, 760, 520);
						outtextxy(700, 500, "返回");// 返回主菜单按钮

						while (1)
						{
							m4 = getmessage();
							if (m4.x > 680 && m4.x < 760 && m4.y > 490 && m4.y < 520)
							{
								setlinecolor(RED);
								rectangle(680, 490, 760, 520);
							}
							else
							{
								setlinecolor(WHITE);
								rectangle(680, 490, 760, 520);
							}
							if (m4.message == WM_LBUTTONDOWN)
							{
								menu();// 返回主菜单
							}
						}
					}
				}
			}
			else
			{
				// 若不存在出边（这种情况可能不符合预期逻辑，但做个错误提示处理）
				ExMessage m4;
				initgraph(800, 620);
				setbkcolor(WHITE);
				cleardevice();

				setbkmode(TRANSPARENT);
				settextcolor(BLACK);
				settextstyle(20, 0, "黑体");

				outtextxy(40, 140, "关键节点无有效出边，无法获取加班成本和加班天数信息");

				fillrectangle(680, 490, 760, 520);
				outtextxy(700, 500, "返回");//返回按钮

				while (1)
				{
					m4 = getmessage();
					if (m4.x > 680 && m4.x < 760 && m4.y > 490 && m4.y < 520)
					{
						setlinecolor(RED);
						rectangle(680, 490, 760, 520);
					}
					else
					{
						setlinecolor(WHITE);
						rectangle(680, 490, 760, 520);
					}
					if (m4.message == WM_LBUTTONDOWN)
					{
						menu();//返回主菜单
					}
				}
			}
		}
		else
		{
			HWND hndtipsF = GetHWnd();
			int isok = MessageBox(hndtipsF, "此节点不是关键节点，没有必要加班!", "提示", MB_OK);
			ExMessage m4;
			initgraph(800, 620);
			IMAGE img3;
			loadimage(&img3, "D:\\课设\\游戏\\游戏\\路线图.jpg", 800, 620);
			putimage(0, 0, &img3);
			fillrectangle(680, 490, 760, 520);

			outtextxy(700, 500, "返回");//返回按钮



			while (1)
			{
				m4 = getmessage();
				if (m4.x > 680 && m4.x < 760 && m4.y > 490 && m4.y < 520)
				{
					setlinecolor(RED);
					rectangle(680, 490, 760, 520);
				}
				else
				{
					setlinecolor(WHITE);
					rectangle(680, 490, 760, 520);
				}
				if (m4.message == WM_LBUTTONDOWN)
				{
					menu();//返回主菜单
				}
			}
		}
	}
}
int findNode()//查找
{
	char Input[30];
	InputBox(Input, 10, "请输入想查询的节点");
	for (int k = 0; k < 20; k++)
	{
		if (strcmp(G.vexname[k], Input) == 0)//两个字符串相等
		{
			return k;
		}
	}

	return -1;
}

void PrintUI(int q)//输出界面
{
	ExMessage m3;
	initgraph(800, 620);
	IMAGE img2;
	loadimage(&img2, "D:\\课设\\最新调试\\res\\背景.jpg", 800, 620);
	putimage(0, 0, &img2);
	setfillcolor(WHITE);
	fillrectangle(680, 490, 760, 520);
	setbkmode(TRANSPARENT);
	settextcolor(BLACK);

	settextstyle(20, 0, "黑体");
	outtextxy(40, 20, "名称");
	outtextxy(200, 20, "距离最早完工时间还有");
	outtextxy(500, 20, "距离最晚完工时间还有");
	outtextxy(700, 500, "返回");//返回按钮

	char ve_str[20];
	char vl_str[20];
	sprintf(ve_str, "%d", ve[19] - ve[q]);
	sprintf(vl_str, "%d", vl[19] - vl[q]);

	outtextxy(40, 140, G.vexname[q]);
	outtextxy(200, 140, vl_str);
	outtextxy(500, 140, ve_str);

	while (1) {
		m3 = getmessage();
		if (m3.x > 680 && m3.x < 760 && m3.y > 490 && m3.y < 520) {
			setlinecolor(RED);
			rectangle(680, 490, 760, 520);
		}
		else {
			setlinecolor(WHITE);
			rectangle(680, 490, 760, 520);
		}
		if (m3.message == WM_LBUTTONDOWN) {
			menu();//返回主菜单
		}
	}
}

void show4()//调用findNode函数，输出成绩界面
{
	int fan1 = findNode();//返回值
	if (fan1 == -1)//没找到
	{
		//获取窗口句柄
		HWND hndtipsF = GetHWnd();
		int isok = MessageBox(hndtipsF, "查无此节点!", "提示", MB_OK);
	}
	else
	{
		PrintUI(fan1);
	}
}

int main(void)//主函数调用
{
	menu();
	return 0;
}

2301_80389709
关注
拓扑排序的原理及其实现
不忘初心，好好沉淀
07-04 21万+
本文将从以下几个方面介绍拓扑排序： 拓扑排序的定义和前置条件和离散数学中偏序/全序概念的联系典型实现算法 Kahn算法基于DFS的算法 解的唯一性问题实际例子 取材自以下材料： http://en.wikipedia.org/wiki/Topological_sorting http://en.wikipedia.org/wiki/Hamiltonian_pat
DAG拓扑排序
一只在校程序猿的技术贴
01-25 840
一个庞大的、复杂的系统工程，往往有一些步骤需要先完成某些工作才能进行，于是要想高效地完成整个工程，就要搞清楚先完成哪些工作，再完成哪些工作，也就是完成的先后顺序。举个简单的例子，计算机专业的学生需要完成整个学业需要学习很多课程，而这些课程之间是相互关联的，不学会一门编程语言（比如C++）就不能学习数据结构，这样编程语言就叫做数据结构的先导课程，需要先学习编程语言再学习数据结构。DAG拓扑排序算法应...
可视化图论算法软件(最终版)
08-13
本软件是用来求解图论算法的可视化软件，修正了目前的bug。
可视化的数据结构和算法
sysu_lluozh
10-14 411
基础 Stack栈: 数组实现Stack栈: 链表实现Queues队列: 数组实现Queues队列: 链表实现Lists列表: 数组实现Lists列表: 链表实现 索引 Binary Search Trees 二叉检索树AVL Trees (平衡二叉检索树)Red-Black Trees 红黑树Open Hash Tables 开放哈希表(Closed
使用函数求最大公约数 pta_13个数学函数应用技巧解读，易学易懂，远离数学计算困扰...
weixin_39797693的博客
11-21 476
Excel中的函数种类很多，其中有一类为数学函数，如果能够熟练掌握，将会远离数学计算的困扰，提高工作效率。一、Excel数学函数：Sign。功能：确定数字的符号，如果为正数、则返回1；如果为0，则返回0；如果为负数，则返回-1。语法：=Sign(数值或引用)。目的：标识商品的销售完成情况。方法：在目标单元格中输入公式：=SIGN(D3-C3)。解读：除了标识商品的销售完成情况外，还可...
数据结构课程设计：拓扑排序与关键路径图形化实现
资源摘要信息:"本资源为数据结构课程设计项目，旨在通过图形化的方式展示邻接链表、关键路径以及拓扑排序。项目文件包括设计报告、源码，并涉及前端技术、echarts图表库和electron框架。项目任务包括建立并显示有向...
如何使用JavaScript结合echarts和electron实现一个具有图形化界面的拓扑排序和关键路径分析工具？
最新发布
10-31
5. 使用echarts库将图的顶点、边以及拓扑排序和关键路径的结果进行可视化。可以通过配置图表类型、颜色、标签和交互功能来定制化展示。 6. 利用electron框架打包前端应用，创建一个可以在不同操作系统上运行的桌面...
数据结构课程设计源码 图子系统
03-21
总的来说，这个数据结构课程设计的图子系统提供了一个实践平台，让你能够亲手实现和探索图的算法，同时通过图形界面加深对图操作的直观认识。这将有助于你在未来的软件开发中更加熟练地处理涉及到图的问题。
关键路径与最短路径算法的实现与可视化
通过以上内容，我们了解到关键路径、迪杰斯特拉算法和弗洛伊德算法在数据结构中的重要性，以及如何利用MFC实现这些算法的可视化界面。掌握这些知识点对于深入学习图论、算法设计与分析至关重要。
JavaScript实现图形化拓扑排序与关键路径分析
本项目是一个关于数据结构课程设计的项目，它涉及到图论中的一些重要概念，包括邻接链表的建立、拓扑排序以及关键路径的确定，并且项目要求通过图形化的方式展现这些算法的执行过程。 ### 邻接链表的建立与显示 ...
拓扑排序-Python实现
高一少年的博客
11-08 772
拓扑排序- TopSort 拓扑序： 如果图中从V到W有一条有向路径，则V一定排在W之前 AOV(Activity On Vertex) 如果有合理的拓扑序，则一定是有向无环图(Directed Acyclic Graph, DAG） graph = { 1:[3], 2:[3,13], 3:[7], 4:[5], 5:[6], 6:[15], ...
拓扑排序JS实现
zjw_python的博客
12-24 1830
1 定义 在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，称为AOV网（Activity On Vertex Network） 设G={V,E}是一个具有n个顶点的有向图，V中的顶点序列v1、v2… 满足若从顶点vi到vj有一条路径，则在顶点序列中顶点vi必须在顶点vj之前，则称这样的顶点序列为一个拓扑序列 拓扑排序就是对一个有向图构造拓扑序列...
拓扑排序(Topological Sorting)算法
贱贱的梦想
05-27 4008
拓扑排序(Topological Sorting)在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序： 每个顶点出现且只出现一次； 若A在序列中排在B的前面，则在图中不存在从B到A的路径。 用顶点表示活动，用弧表示活动之间的优先关系，这样的有向图为顶点表示活动的网，称为AOV网（Activity On Vertex Network）。 另外，AOV网是一种有
拓扑排序和关键路径的图形化显示
毕业作品网站
07-03 847
在第一次进行拓扑排序时，栈中应该是有初始入度为0的节点，之后弹出栈顶元素，然该元素所指的其他的节点的入度减一，并且监测入度改变，如果该节点入度变为了零，则将该节点也加入栈中，这样做保证了寻找其他的入度为 0 的点不会产生额外开销。在完成拓扑排序之后，需要实现的是关键路径算法。具体的实现方法也是对输入得到的邻接矩阵实现关键路径算法，计算出各个顶点的最早开始时间以及最晚开始时间，进而计算出各个边上的最早和最晚开始时间，并且计算出关键路径，并且将相关的信息存储到图像显示的配置项当中，从而完成对关键路径的显示。
图综合练习--拓扑排序_拓扑图怎么画？一款好用可视化工具推荐
weixin_39638464的博客
12-05 686
拓扑图又称拓扑结构图，是指由计算机、打印机、网络设备以及其他设备构成的网络结构图。通俗来讲，就是将实物连接用图形呈现出来。其很大程度影响网络如何工作的。拓扑图常见的用途拓扑图通过图形可以更直观表明网络中各节点和端口之间的连接，反应出各实体间的结构关系，方便配置和排除错误。拓扑图包括物理拓扑和逻辑拓扑。物理拓扑：指的是设备如何用线缆物理连接；逻辑拓扑：设备间如何通过物理拓扑实现通信；拓扑图绘制方法只...
拓扑排序——JS+Echats实现
hhthht8888的博客
12-03 494
拓扑排序算法主要过程： 1.创建一个数组记录每个节点的前驱节点数目。 2.运用递归，每一次递归中，找出没有前驱节点的节点，输出该节点，并做相关标记（或删去）；然后找到该节点引出的连接，做相关标记（或删去）。 3.递归终止条件：所有的节点都已经被标记（或被删去），或者找不到没有前驱节点的节点。 核心代码如下： sort = function(){ //找到没有前驱节点的节点 ...
【图论】有向无环图的拓扑排序
weixin_34354945的博客
12-29 621
1. 引言 有向无环图（Directed Acyclic Graph, DAG）是有向图的一种，字面意思的理解就是图中没有环。常常被用来表示事件之间的驱动依赖关系，管理任务之间的调度。拓扑排序是对DAG的顶点进行排序，使得对每一条有向边(u, v)，均有u（在排序记录中）比v先出现。亦可理解为对某点v而言，只有当v的所有源点均出现了，v才能出现。 下图给出有向无环图的拓扑排序： 下图给出的顶点排...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值