devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于数据结构解决教学计划编制问题_拓扑排序教学编制计划数据结构

作者：煮酒与君饮 | 2024-06-25 06:28:01

赞

踩

拓扑排序教学编制计划数据结构

摘  要

教学计划是学校保证教学质量和人才培养的关键，也是组织教学过程、安排教学过程、安排教学任务、确定教学编排的基本依据和课程安排的具体形式。是稳定教学秩序、提高教学质量的重要保证。从教学计划的设计、实施等方面，阐明了如何搞好教学管理，从而为提高教学质量提供保证。随着教育改革的不断深入和社会发展的需要，原旧的教学计划在定位上的方向性偏差，已经不再适应社会的需求。因此，应重视教学计划的改革和修订工作，以确保教育教学质量，提高教育教学水平。教学计划编制中的思路：一是明确培养目标；二是注重学科设置的整体性、统一性和灵活性、全面性；三是与学分制改革有机结合。

教学计划是高校实施常规教学活动的基本管理文档，由于传统的手工编制方式存在诸多弊端，开发基于Web应用程序形式的教学计划编制系统具有良好的应用价值。使用C程序设计语言，研发开发教学计划编制系统Web应用系统。

关键词：教学计划  编制  C程序设计语言  管理  

 设计题目

大学的每个专业都要编制教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限都相等。每个专业开设的课程都是确定的，而且课程的开设时间的安排必须满足先修关系。每个课程的先修关系都是确定的，可以有任意多门，也可以没有。每一门课程恰好一个学期。试在这样的情况下设置一个教学计划编制程序。

在大学的某个专业中选取几个课程作为顶点,通过各门课的先修关系来构建个图,该图用邻接表来存储,邻接表的头结点存储每门课的信息。

本程序的目的是为用户编排课程,根据用户输入的信息来编排出每学期要学的课程。

第二章  需求分析

2.1 运行环境（软、硬环境）

设计环境和器材——

硬件：计算机

软件：Microsoft Visula C++

在本课程设计中，系统开发平台为Windows XP或Win 7，程序运行环境为Visual C++ 6.0，程序设计语言为C++。Visual C++一般分为三个版本：学习版、专业版和企业版，不同版本适合于不同类型的应用开发。实验中可以使用这三个版本的任意一种，在本课程设计中，以Visual C++ 6.0为编程环境。

Visual C++以拥有“语法高亮”，IntelliSense（自动编译功能）以及高级除错功能而著称。比如，它允许用户进行远程调试和单步执行等。还有允许用户在调试期间重新编译被修改的代码，而不必重新启动正在调试的程序。其编译及建置系统以预编译头文件、最小重建功能及累加链接著称。这些特征明显缩短程式编辑、编译及链接的时间花费，在大型软件计划上尤其显著。

Visual C++ 6.0秉承Visual C++ 以前版本的优异特性，为用户提供了一套良好的开发环境，主要包括文本编辑器、资源编辑器、工程创建工具和Debugger调试器等等。用户可以在集成开发环境中创建工程，打开工程，建立、打开和编辑文本，编译、链接、运行和调试应用程序。

2.2 输入的形式和输入值的范围

数据输入的方式是键盘输入。输入的数据多是整型的或是浮点型的，还有一些字符（以中文的形式）。输入的数值型的数据大都是小于100的数值。

2.3 输出的形式描述

输出的是教学编制计划，就是形如：“第二学期学的课程有:普通物理 线性代数 汇编语言”这样的形式。

2.4 功能描述

输入参数包括：学期总数，一学期的学分上限，每门课的课程号(固定占3位的字母数字串)、学分和直接先修课的课程号。

允许用户指定下列两种编排策略之一：一是使学生在各学期中的学习负担尽量均匀；二是使课程尽可能地集中在前几个学期中。

若根据给定的条件问题无解，则报告适当的信息；否则将教学计划输出到用户指定的文件中。计划的表格格式自行设计。

2.5 测试数据

学期总数：6 

学分上限：10

该专业共开设12门课，课程号从01~12，学分顺序为2，3，4，2，2，4，4，4，7，5，2，3。

第三章  概要设计

3.1 抽象数据类型定义描述

（对各类的成员及成员函数进行抽象描述）。

抽象数据类型：

为实现上述功能需建立一个结点类，线性表类，图类。

ADT Graph{

数据对象V:V是具有相同特性的数据元素的集合,称为顶点集。

数据关系R:

R={VR}

VR={(v,w)|v,w∈V,(v,w)表示v和w之间存在直接先修关系}

基本操作P:

void creatpre(AlGraph *CGraph);

void findindegree(AlGraph *CGraph,int indegree[]);

void layout1(AlGraph *CGraph,queue *q);

void layout2(AlGraph *CGraph,queue *q);

}ADT Graph

队列的定义:

ADT List{

数据对象:D={ai|ai∈ElemSet,i=1,2,…n,n>=0}

数据关系:R1={﹤ai-1 ai﹥|ai-1,ai∈D,i=2,…,n}

基本操作:

void queue_init(queue *q);

void queue_in(queue *q,int x);

int queue_out(queue *q);

int queue_empty(queue *q);

}ADT Stack

3.2 功能模块设计

主程序：

void main()

{

int choice;

queue q;

Queue.queue_init(&q);

AlGraph CGraph;

CGraph=Graph.input();

system("cls");

Graph.output(CGraph);

cout<<endl<<endl;

Judgement.judgingcricle(&CGraph,&q);

if(!WhetherCricle)

{

while(1)

{

cout<<"请选择编排策略:\t"<<endl;

cout<<"1.使学生在各学期中的学习负担尽量均匀;\t"<<endl;

cout<<"2.使课程尽可能地集中在前几个学期中。\t"<<endl;

cout<<"请选择:";

cin>>choice;

system("cls");

if(choice==1)

Edit.layout1(&CGraph,&q);

else

Edit.layout2(&CGraph,&q);

cout<<"请选择继续编排策略或退出程序（0退出 1继续）:\t"<<endl;

cin>>choice;

system("cls");

if(choice==0)

break;

}

}

}

3.3 模块层次调用关系

本程序只有两个模块,调用关系简单：主程序模块→拓扑排序模块

TopSort流程图

第四章 详细设计

教学计划编制系统主要是处理课程之间的依赖关系。表列出了若干门计算机系本科课程，其中有些课程不要求先修课程，例如，C1是独立于其他课程的基础课，而有些课程却需要有先修课程，比如，学完程序设计语言C++和离散数学后才能学习数据结构。

课程代号

课程名称

先修课程

C1

高等代数

无

C2

计算机科学导论

无

C3

离散数学

C1

C4

程序设计语言C++

C1 C2

C5

数据结构

C3 C4

C6

计算机原理

C2 C4

C7

数据库原理

C4 C5 C6

先修课程规定了课程之间的依赖关系，这种关系可以用AOV网来表示，其中顶点表示课程，弧表示依赖关系。

程序的主要功能是实现课程的排序，以满足同一学期所修的课程相互之间无依赖关系，并且已修完其所有先修课程。本程序需要基于图的基本操作来实现。

算法的基本思想：

 1、数据的定义：

给出课程号、课程、先修的课程结点、课程结点、邻接表、课程图的定义。

邻接表的定义：

邻接表是一种顺序存储与链接存储相结合的存储方法。在邻接表中存在两种结点结构：顶点表结点和边表结点。

 2、图的构建：

建立一个结点类，类的元素有字符型变量用来存储字母，整形变量用来存储位置，该类型的指针，指向下一个元素。建立一个线性表类，完成线性表的构建。建立一个图类，完成图的信息的读取，（如有n个点，则建立n个线性表，将每个结点与其指向的结点组成一个线性表，并记录线性表的长度）。

3、队的初始化：

令头指针和尾指针置于0，表示队列为空。

void Queue::queue_init(queue *q) //队初始化

{

q->f=q->r=0;                        //头指针和尾指针置于0，表示队列为空

}

4、入队操作：

判断队列是否满，若队满输出“队满”。否则，将队尾指针加1，再将新元素插入队尾。

void Queue::queue_in(queue *q,int x) //入队

{

if((q->r+1)%MAX_COURSE_NUM==q->f)

{

cout<<"队满\t"<<endl;

exit(0);

}

q->r=(q->r+1)%MAX_COURSE_NUM;       //队尾指针加1

q->data[q->r]=x;                    //新元素插入队尾

}

5、出队操作：

先判断队列是否为空，若空则输出“队空”；否则保存队头元素，将队头指针加1。

int Queue::queue_out(queue *q) //出队

{

if(q->f==q->r)                          //判断队空

{

cout<<"队空\t"<<endl;

exit(0);

}

q->f=(q->f+1)%MAX_COURSE_NUM;           //队头指针加1

return q->data[q->f];                   //保存队头元素

}

6、建立先修关系：

输入课程的编号，在输入每一门课程的先修课程编号。判断输入的课程编号是否正确，若不正确，则输出“先修课程号不可能是本课程号”。否则，令p的邻接点等于j-1，p邻接的下一条边的结点为空，当元素为空时，令表头结点为p，令q等于表头结点；否则，让与q邻接的下一条边的结点是p，q等于p。

p=(PreCourse *)malloc(sizeof(PreCourse)); p->adjvex=j-1;

p->nextarc=null;

if(n==0)

{

CGraph->courses[i].firstarc=p;

q=CGraph->courses[i].firstarc;

n++;

}

else

{

q->nextarc=p;

q=p;

n++;

}

cin>>j;

}

}

cout<<"(1)重新建立先修关系\t"<<"(2)确定\n";

cout<<"请选择:";

cin>>choice;

if(choice==1)

creatpre(CGraph);

jxq=0;

}

7、建立课程图：

输入课程号、课程名、学分，判断输入是否正确，若不正确，则输出“输入的学分有误，请重新输入学分:”；调用creatpre()函数建立先修关系，建立课程图

AlGraph Graph::input() //输入并建立课程图

{

AlGraph CGraph;

int xqzs=0,kczs=0;      

int i;

int choice;

float xf,xfsx=0;

cout<<"教学计划编制\n"<<endl;

cout<<"输入参数:\n";

cout<<"1.学期总数:";

cin>>xqzs;

CGraph.xqs=xqzs;

cout<<"2.专业共开设课程数:";

cin>>kczs;

CGraph.num=kczs;

cout<<"3.学分上限(每个学期的学分上限都一样):";

cin>>xfsx;

CGraph.xfsx=xfsx;

cout<<"4.每门课的课程号(固定占3位的字母数字串)、课程名、学分--"<<endl;

for(i=0;i<kczs;i++) //输入课程号，课程名，学分

{

cout<<"课程号:";

scanf("%s",CGraph.courses[i].course.id);

cout<<"课程名:";

scanf("%s",CGraph.courses[i].course.name);

cout<<"学分:";

cin>>xf;

cout<<endl;

while(xf>xfsx||xf<=0) //判断输入的学分是否合格

{

cout<<"输入的学分有误，请重新输入学分:";

cin>>xf;

}

CGraph.courses[i].course.xf=xf;

CGraph.courses[i].firstarc=null;

}

cout<<"(1)重新输入\t"<<"(2)确定"<<endl;

cout<<"请选择:";

cin>>choice;

if(choice==1)

{

system("cls");

input();

}

else

{

creatpre(&CGraph); //建立先修关系

return CGraph;

}

}

8、Topsort算法：

先计算每个点的入度，保存在数组中。找到第一个入度为0的点，将该点所连的各点的入度减一。再在这些点中找入度为0 的点。如果找到，重复上述操作。如果找不到，则跳出while循环，再搜索其他的点，看入度是否为0。再重复上述操作，如果所有的入度为0的点都被寻找到，但个数少于输入顶点的个数，说明该图存在环。

while(1)

{

i=Queue.queue_out(&q);

Queue.queue_in(q2,i);

if(i!=-1)

{

m++;

for(j=0;j<CGraph->num;j++)

if(j!=i)

{

if(indegree[j]==0&&(xf+CGraph->courses[j].course.xf)<=CGraph->xfsx)

{

Queue.queue_in(&q,j);

indegree[j]--;

xf+=CGraph->courses[j].course.xf;

}

else

{

p=CGraph->courses[j].firstarc;

while(p)

{

if(p->adjvex==i)

{

indegree[j]--;

if(indegree[j]==0&&(xf+CGraph->courses[j].course.xf)<=CGraph->xfsx)

{

Queue.queue_in(&q,j);

indegree[j]--;

pd=1;

xf+=CGraph->courses[j].course.xf;

}

}

p=p->nextarc;

}

}

}

}

else

{

if(pd)

{

pd=0;

Queue.queue_in(&q,-1);

jxq++;

xf=0;

}

else break;

}

}

if(jxq>CGraph->xqs)

{cout<<endl<<"错误报告：\n"<<"在"<<CGraph->xqs<<"学期内是无法修完这些课程"<<endl;

exit(0);}

if(m<CGraph->num)

{

cout<<"\n错误报告："<<endl;

cout<<"存在循环，因此课程安排不了"<<endl;

WhetherCricle=1;

}

Queue.queue_in(q2,-1);}

程序完整代码

  1. 附  录
  2. #include<iostream>
  3. #include<string>
  4. #include<cstdio>
  5. #include<cstdlib>
  6. using namespace std;
  7. #define null 0
  8. #define MAX_COURSE_NUM 100						//最大课程个数
  9.  
  10. typedef struct   
  11.  {
  12. 	char c[3];
  13.  }cid;									 //课程号
  14.  
  15. typedef struct Course  
  16.  {  
  17.    cid id[3];							
  18.    char name[30];						
  19.    float  xf;							
  20.  }Course;								//课程
  21.  
  22. typedef struct PreCourse        
  23. {
  24. 	int adjvex;							
  25. 	struct  PreCourse *nextarc;				 
  26. }PreCourse;								//先修的课程节点
  27.  
  28. typedef struct
  29. {	
  30. 	Course course;						
  31. 	PreCourse *firstarc;				
  32. }CourseNode;							//课程节点
  33.  
  34. typedef struct
  35. {
  36. 	CourseNode courses[MAX_COURSE_NUM];		//邻接表
  37. 	int xqs;							
  38. 	int num;							
  39. 	float xfsx;							
  40. }AlGraph;								//课程图
  41.  
  42. typedef struct 
  43. {
  44. 	int data[MAX_COURSE_NUM];					
  45. 	int f,r;							
  46. }queue;
  47.  
  48. int WhetherCricle=0;							
  49. int jxq;								
  50.  
  51. class Queue
  52. {
  53. public:
  54. 	void queue_init(queue *q);
  55. 	void queue_in(queue *q,int x);
  56. 	int queue_out(queue *q);
  57. 	int queue_empty(queue *q);
  58. }Queue;
  59.  
  60. void Queue::queue_init(queue *q)				//队初始化
  61. {
  62. 	q->f=q->r=0;
  63. }
  64.  
  65. void Queue::queue_in(queue *q,int x)			//入队
  66. {
  67. 	if((q->r+1)%MAX_COURSE_NUM==q->f)
  68. 	{
  69. 		cout<<"队满\t"<<endl;
  70. 		exit(0);
  71. 	}
  72. 	q->r=(q->r+1)%MAX_COURSE_NUM;
  73. 	q->data[q->r]=x;
  74. }
  75.  
  76. int Queue::queue_out(queue *q)					//出队
  77. {
  78. 	if(q->f==q->r)
  79. 	{
  80. 		cout<<"队空\t"<<endl;
  81. 		exit(0);
  82. 	}
  83. 	q->f=(q->f+1)%MAX_COURSE_NUM;
  84. 	return q->data[q->f];
  85. }
  86.  
  87. int Queue::queue_empty(queue *q)				//队判空 1为空
  88. {
  89. 	if(q->f==q->r)
  90. 		return 1;
  91. 	else return 0;
  92. }
  93.  
  94. class Graph
  95. {
  96. public:
  97. 	AlGraph input();
  98. 	void output(AlGraph CGraph);
  99. 	void creatpre(AlGraph *CGraph);
  100. }Graph;
  101.  
  102. void Graph::creatpre(AlGraph *CGraph)			//建立先修关系
  103. {
  104. 	system("cls");						
  105. 	int choice;
  106. 	int i,n;							 
  107. 	int j;
  108. 	PreCourse *p,*q;					
  109. 	cout<<endl<<"建立先修关系:\t"<<endl;
  110. 	cout<<endl<<"输入的每一门课程号的编号：\t"<<endl;
  111. 	for(i=0;i<CGraph->num;i++)
  112. 	{
  113. 		if(i%4==0)
  114. 			cout<<endl;
  115. 		cout<<"("<<i+1<<")";				//输入课程的编号
  116. 		printf("%s\t",CGraph->courses[i].course.id);	
  117. 	}
  118. 	cout<<endl;
  119. 	cout<<"\n请根据以上的编号，输入每一门课程的先修课程号的编号（输入0 表示没有或结束）：\t"<<endl;
  120. 	for(i=0;i<CGraph->num;i++)
  121. 	{
  122. 		printf("%s的先修课程:",CGraph->courses[i].course.id);
  123. 		cin>>j;
  124. 		n=0;
  125. 		while(j)						//判断输入的课程编号是否正确
  126. 		{
  127. 			while(j<1||j>CGraph->num||j==i+1)
  128. 			{			
  129. 				if(j==i+1)				
  130. 					cout<<"先修课程号不可能是本课程号\n";			
  131. 				else				
  132. cout<<"输入的先修课程号不在该专业开设的课程序列中"<<endl;
  133. 				cout<<"请重新输入:";
  134. 				cin>>j;
  135. 			}	
  136. 			p=(PreCourse *)malloc(sizeof(PreCourse));					p->adjvex=j-1;
  137. 			p->nextarc=null;
  138. 			if(n==0)
  139. 			{	
  140. 				CGraph->courses[i].firstarc=p;
  141. 				q=CGraph->courses[i].firstarc;
  142. 				n++;
  143. 			}
  144. 			else
  145. 			{
  146. 				q->nextarc=p;
  147. 				q=p;
  148. 				n++;
  149. 			}
  150. 			cin>>j;
  151. 		}
  152. 	}
  153. 	cout<<"(1)重新建立先修关系\t"<<"(2)确定\n";
  154. 	cout<<"请选择:";
  155. 	cin>>choice;
  156. 	if(choice==1)
  157. 		creatpre(CGraph);
  158. 	jxq=0;
  159. }
  160.  
  161. AlGraph Graph::input()						//输入并建立课程图
  162. {
  163. 	AlGraph CGraph;
  164. 	int xqzs=0,kczs=0;				     
  165. 	int i;			
  166. 	int choice;
  167. 	float xf,xfsx=0;				
  168. 	cout<<"教学计划编制\n"<<endl;
  169. 	cout<<"输入参数:\n";
  170. 	cout<<"1.学期总数:";
  171. 	cin>>xqzs;
  172. 	CGraph.xqs=xqzs;
  173. 	cout<<"2.专业共开设课程数:";
  174. 	cin>>kczs;
  175. 	CGraph.num=kczs;				
  176. 	cout<<"3.学分上限(每个学期的学分上限都一样):";
  177. 	cin>>xfsx;
  178. 	CGraph.xfsx=xfsx;
  179. 	cout<<"4.每门课的课程号(固定占3位的字母数字串)、课程名、学分--"<<endl;
  180. 	for(i=0;i<kczs;i++)				//输入课程号，课程名，学分
  181. 	{
  182. 		cout<<"课程号:";
  183. 		scanf("%s",CGraph.courses[i].course.id);
  184. 		cout<<"课程名:";
  185. 		scanf("%s",CGraph.courses[i].course.name);
  186. 		cout<<"学分:";
  187. 		cin>>xf;
  188. 		cout<<endl;
  189. 		while(xf>xfsx||xf<=0)			//判断输入的学分是否合格
  190. 		{
  191. 			cout<<"输入的学分有误，请重新输入学分:";
  192. 			cin>>xf;
  193. 		}
  194. 		CGraph.courses[i].course.xf=xf;
  195. 		CGraph.courses[i].firstarc=null;
  196. 	}
  197. 	cout<<"(1)重新输入\t"<<"(2)确定"<<endl;
  198. 	cout<<"请选择:";
  199. 	cin>>choice;
  200. 	if(choice==1)
  201. 	{
  202. 		system("cls");	
  203. 		input();
  204. 	}
  205. 	else 
  206. 	{
  207. 		creatpre(&CGraph);				//建立先修关系
  208. 		return CGraph;
  209. 	}
  210. }
  211.  
  212. void Graph::output(AlGraph CGraph)			///输出先修关系
  213. {
  214. 	int i,j,n;	
  215. 	PreCourse *p;	
  216. 	cout<<"先修关系如下:\n"<<endl;
  217. 	cout<<"课程编号\t"<<"课程名称\t"<<"先决条件"<<endl;
  218. 	for(i=0;i<CGraph.num;i++)
  219. 	{
  220. 		printf("%s\t\t%s\t\t",CGraph.courses[i].course.id,CGraph.courses[i].course.name);
  221. 		j=0;
  222. 		p=CGraph.courses[i].firstarc;
  223. 		while(p)
  224. 		{
  225. 			n=p->adjvex;
  226. 			printf(" %s  ",CGraph.courses[n].course.id);
  227. 			p=p->nextarc;
  228. 			j++;
  229. 		}
  230. 		if(j==0)
  231. 			cout<<" 无";
  232. 		cout<<endl;
  233. 	}
  234. }
  235.  
  236. class Judgement
  237. {
  238. public:
  239. 	void findindegree(AlGraph *CGraph,int indegree[]);
  240. 	void judgingcricle(AlGraph *CGraph,queue *q2);
  241. }Judgement;
  242.  
  243. void Judgement::findindegree(AlGraph *CGraph,int indegree[])	
  244. {
  245. 	int i;
  246. 	PreCourse *p;
  247. 	for(i=0;i<CGraph->num;i++)
  248. 	{
  249. 		indegree[i]=0;
  250. 		p=CGraph->courses[i].firstarc;
  251. 		while(p)
  252. 		{
  253. 			indegree[i]++;
  254. 			p=p->nextarc;
  255. 		}
  256. 	}
  257. }
  258.  
  259. void Judgement::judgingcricle(AlGraph *CGraph,queue *q2)			//判断是否有环和课程入队
  260. {
  261. 	int indegree[MAX_COURSE_NUM];								//入度
  262. 	int i,m,j,pd=0;
  263. 	float xf=0;
  264. 	PreCourse *p;
  265. 	queue q;
  266. 	Queue.queue_init(&q);							//队初始化
  267. 	findindegree(CGraph,indegree);						//找入度
  268. 	for(i=0;i<CGraph->num;i++)
  269. 	{
  270. 	if(indegree[i]==0&&(xf+CGraph->courses[i].course.xf)<=CGraph->xfsx)				
  271. {
  272. 			Queue.queue_in(&q,i);
  273. 			indegree[i]--;
  274. 			xf+=CGraph->courses[i].course.xf;
  275. 		}
  276. 	}
  277. 	m=0;
  278. 	xf=0;
  279. 	Queue.queue_in(&q,-1);          //把-1入队  用来判断
  280. 	jxq++;
  281. 	while(1)
  282. 	{
  283. 		i=Queue.queue_out(&q);
  284. 		Queue.queue_in(q2,i);
  285. 		if(i!=-1)
  286. 		{
  287. 			m++;
  288. 			for(j=0;j<CGraph->num;j++)
  289. 			if(j!=i)
  290. 			{	
  291. 	if(indegree[j]==0&&(xf+CGraph->courses[j].course.xf)<=CGraph->xfsx)						
  292. 	{
  293. 					Queue.queue_in(&q,j);
  294. 					indegree[j]--;
  295. 					xf+=CGraph->courses[j].course.xf;
  296. 				}
  297. 				else
  298. 				{
  299. 					p=CGraph->courses[j].firstarc;
  300. 					while(p)
  301. 					{
  302. 						if(p->adjvex==i)
  303. 						{
  304. 							indegree[j]--;
  305. 				if(indegree[j]==0&&(xf+CGraph->courses[j].course.xf)<=CGraph->xfsx)
  306. 							{
  307. 								Queue.queue_in(&q,j);
  308. 								indegree[j]--;
  309. 								pd=1;
  310. 								xf+=CGraph->courses[j].course.xf;
  311. 							}
  312. 						}
  313. 						p=p->nextarc;
  314. 					}
  315. 				}
  316. 			}
  317. 			
  318. 		}
  319. 		else
  320. 		{
  321. 			if(pd)
  322. 			{
  323. 				pd=0;
  324. 				Queue.queue_in(&q,-1);
  325. 				jxq++;
  326. 				xf=0;
  327. 			}
  328. 			else break;
  329. 		}
  330. 	}
  331. 	if(jxq>CGraph->xqs)
  332. 	{cout<<endl<<"错误报告：\n"<<"在"<<CGraph->xqs<<"学期内是无法修完这些课程"<<endl;
  333. 		exit(0);}
  334. 	if(m<CGraph->num)
  335. 	{
  336. 		cout<<"\n错误报告："<<endl;
  337. 		cout<<"存在循环，因此课程安排不了"<<endl;
  338. 		WhetherCricle=1;
  339. 	}
  340. 	Queue.queue_in(q2,-1);}
  341.  
  342. class Edit
  343. {
  344. public:
  345. 	void layout1(AlGraph *CGraph,queue *q);
  346. 	void layout2(AlGraph *CGraph,queue *q);
  347. }Edit;
  348.  
  349. void Edit::layout1(AlGraph *CGraph,queue *q)								{cout<<"\n学生在各学期中的学习负担尽量均匀:\n"<<endl;
  350. 	int i,j,k,xq=1,ck[20];
  351. 	float xf;
  352. 	float m=CGraph->num/CGraph->xqs*1.0f;								queue q1=*q;
  353. 	int n;int x;
  354. 	n=0;
  355. 	ck[0]=-1;
  356. 	for(i=0;i<20;i++)
  357. 	{j=Queue.queue_out(&q1);
  358. 		ck[i]=j;
  359. 		if(j==-1) 
  360. 			i--;
  361. 		if((Queue.queue_empty(&q1))) 
  362. 			break;
  363. 	}
  364. 	for(x=0;x<CGraph->xqs;x++)
  365. 	{
  366. 		if(ck[0]!=-1)
  367. 		{
  368. 			cout<<"\n第"<<xq++<<"学期学：";
  369. 			xf=0;
  370. 			for(i=0;i<m;i++)
  371. 			{
  372. 				k=ck[n];
  373. 				printf(" %s  ",CGraph->courses[k].course.id);
  374. 				n++;
  375. 				xf+=CGraph->courses[k].course.xf;}
  376. 			cout<<"获得学分是:"<<xf<<endl;}
  377. 	}		
  378. }
  379. void Edit::layout2(AlGraph *CGraph,queue *q)								{
  380. 	cout<<"\n课程尽可能地集中在前几个学期中:\n"<<endl;
  381.     int i,j,xq=1;
  382. 	float xf;
  383. 	cout<<"\n第"<<xq<<"学期学：";
  384. 	xq++;
  385. 	xf=0;
  386. 	queue q1=*q;
  387. 	for(i=1;i<=CGraph->num;)
  388. 	{
  389. 		j=Queue.queue_out(&q1);
  390. 		if(j!=-1)
  391. 		{
  392. 			printf(" %s  ",CGraph->courses[j].course.id);
  393. 			i++;
  394. 			xf+=CGraph->courses[j].course.xf;
  395. 		}
  396. 		else
  397. 		{
  398. 			cout<<"获得学分是:"<<xf;	
  399. 			cout<<"\n第"<<xq++<<"学期学：";
  400. 			xf=0;
  401. 		}	
  402. 	}
  403. 	cout<<"获得学分是:"<<xf<<endl;
  404. 	if(xq<=CGraph->xqs)
  405. 	{
  406. 		cout<<"\n第"<<xq++<<"学期学：无\n"<<endl;
  407. 	}
  408. 	
  409. }
  410. void main()
  411. {	
  412. 	int choice;
  413. 	queue q;									
  414. 	Queue.queue_init(&q);								
  415. 	AlGraph CGraph;								
  416. 	CGraph=Graph.input();								
  417. 	system("cls");								
  418. 	Graph.output(CGraph);								
  419. 	cout<<endl<<endl;
  420. 	Judgement.judgingcricle(&CGraph,&q);					
  421. 	if(!WhetherCricle)
  422. 	{
  423. 		while(1)
  424. 		{
  425. 			cout<<"请选择编排策略:\t"<<endl;
  426. 			cout<<"1.使学生在各学期中的学习负担尽量均匀;\t"<<endl;
  427. 			cout<<"2.使课程尽可能地集中在前几个学期中。\t"<<endl;
  428. 			cout<<"请选择:";
  429. 			cin>>choice;					
  430. 			system("cls");
  431. 			if(choice==1) 
  432. 			Edit.layout1(&CGraph,&q);					
  433. 			else 
  434. 			Edit.layout2(&CGraph,&q);				
  435. 			cout<<"请选择继续编排策略或退出程序（0退出 1继续）:\t"<<endl;
  436. 			cin>>choice;
  437. 			system("cls");
  438. 			if(choice==0)
  439. 				break; 
  440. 		}			
  441.

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/755343
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号