教学计划编制问题.doc

目 录
1 课题需求描述 3
1。1 教学计划编制问题3
1。2 进制转换3
2 总体功能与数据结构设计 4
2.1 总体功能结构4
2。2 数据结构设计5
3 算法设计和程序设计 7
3。1 教学计划编制问题7
3。2 进制转换问题10
4 调试与测试 24
4。1 教学计划编制问题调试结果24
4.2 进制转换问题调试结果26
5 设计总结 28
6 程序代码 30
1 课题需求描述
1.1 教学计划编制问题
大学的每个专业都要制订教学计划.假设任何专业都有固定的学习年限，每学年含两学期,每学期的时间长度和学分上限均相等.每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门,也可以没有。每门课恰好占一个学期.在这样的前提下设计一个教学计划编制程序。通过输入实际的课程及先后关系.结合每学期的学分及课程数,制定好学习计划.在输入相关数据后，程序会安排好每学期的课程。
1。2 进制转换
进制数制是人们利用符号进行计数的科学方法。数制有很多种，在计算机中常用的数制有:十进制，二进制，八进制和十六进制。十六进制数有两个基本特点：它由十六个字符0～9以及A,B，C，D，E，F组成（它们分别表示十进制0~15），十六进制数运算规律逢十六进一.
要求：
（1） 输入一个十进制数N，将它转换成R进制数输出，并可以进行你转换.
（2） 输入数据包含多个测试实例,每个测试实例包含两个整数N（32位整数）和R（2〈=R〈=16）。
（3） 为每个测试实例输出转换后的数，每个输出占一行.如果R大于10，则对应的数字规则参考16进制（比如，10用A表示，等等).
2 总体功能与数据结构设计
1．教学计划编制问题
根据问题描述及要求，可知设计中需要定义先修关系的AOV网图中的顶点及弧边的结构体，在运行结果中将图的信息显示出来,利用先修关系将课程排序，最后解决问题—-输出每学期的课程。
2。 进制转换问题
由于计算机只能识别二进制，所以当我们从键盘输入其他进制数的时候，计算机内部的系统会利用自带的程序代码自动转换成二进制，我们是学计算机的,所以我们需要弄懂这种机制转换的原理并且能计算出来.
2.1 总体功能结构
2。1.1 教学计划编制问题
教学计划是学校保证教学质量和人才培养的关键，也是组织教学过程、安排教学过程、安排教学任务、确定教学编制的基本依据和课程安排的具体形式.是稳定教学秩序、提高教学质量的重要保证。从教学计划的设计、实施等方面,阐明了如何搞好教学管理，从而为提高教学质量提供保证。随着教育改革的不断深入和社会发展的需要,原旧的教学计划在定位上的方向性偏差,已经不再适应社会的需求。因此,应重视教学计划的改革和修订工作，以确保教育教学质量,提高教育教学水平.教学计划编制中的思路：一是明确培养目标；二是注重学科设置的整体性、统一性和灵活性、全面性；三是与学分制改革有机结合。  
教学计划是高校实施常规教学活动的基本管理文档,由于传统的手工编制方式存在诸多弊端，开发基于Web应用程序形式的教学计划编制系统具有很好的应用价值.使用C程序设计语言,研究开发教学计划编制系统Web应用系统。
2。1。2 进制转换问题
1。十进制数与非十进制数之间的转换
（1)十进制数转换成非十进制数 把一个十进制数转换成非十进制数（基数记作R）分成两步。整数部分转换时采用“除R取余法";小数部分转换时采用“乘R取整法”.
（2）非十进制数转换成十进制数 非十进制数(基数记作R,第j个数位的位权记作Rj）转换成十进制数的方法：按权展开求其和。
2。非十进制数之间的转换
(1）二进制数与八进制数之间的转换 ①二进制数转换成八进制数的方法.以小数点分界，整数部分自右向左、小数部分自左向右，每三位一组，不足三位时，整数部分在高位左边补0,小数部分在低位右边补0，然后写出对应的八进制数码. ②八进制数转换成二进制数的方法:用八进制数码对应的三位二进制数代替八进制数码本身即可.
（2)二进制数与十六进制数之间的转换 ①二进制数转换成十六进制数的方法:以小数点分界，整数部分自右向左、小数部分自左向右,每四位一组，不足四位时，整数部分在高位左边补0，小数部分在低位右边补0，然后写出对应的十六进制数码。 ②十六进制数转换成二进制数的方法：用十六进制数码对应的四位二进制数代替十六进制数码本身即可.
2.2 数据结构设计
2.2。1 教学计划编制问题
LocateVex（）：图的邻接表存储的基本操作
CreateGraph（）:构造生成树
Display（）：输出图的邻接矩阵
FindInDegree（）:求顶点的入度
InitStack（）:构造一个空栈
ClearStack（）：清空栈
StackEmpty(）：判断是否为空栈
Pop（):出栈
Push（）：入栈
TopologicalSort（)：输出G顶点的拓扑排序结果
2。2。2 进制转换问题
void D_B(）： 十进制转换为二进制
void D_O（）： 十进制转换为八进制
void D_X(）: 十进制转换为十六进制
void B_D（）： 二进制转换为十进制
void B_O(）： 二进制转换为八进制
void B_X（）： 二进制转换为十六进制
void O_B（): 八进制转换为二进制
void O_D(）: 八进制转换为十进制
void O_X（）: 八进制转换为十六进制
void X_B（）： 十六进制转换为二进制
void X_D（)： 十六进制转换为十进制
void X_O（）: 十六进制转换为八进制
3 算法设计和程序设计
3。1 教学计划编制问题
3。1。1采用C语言定义相关的数据类型.
其中包括字符常量，整型，字符型，字符串型，typedef 定义的类型，结构体型,单链表节点类型，结构体数组。
3.1。2主要函数的流程图
1。LocateVex（）：图的邻接表存储的基本操作。由初始条件G存在，u和G中顶点有相同特征转而进行判断,若G中存在顶点u,则返回该顶点在图中位置；否则返回-1。
2。CreateGraph(）:构造生成图。采用邻接表存储结构，构造没有相关信息的图G（用一个函数构造种图)。
3.Display（)：输出图的邻接矩阵。采用循环设置输出图的邻接矩阵。
4。FindInDegree（):求顶点的入度。
5.InitStack（）:构造一个空栈.
6。ClearStack(）：清空栈.
7.StackEmpty（)：判断栈是否为空.若栈S为空栈，则返回TRUE，否则返回FALSE。
8.Pop（）：出栈.若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR。
9。Push（）:入栈。插入元素e为新的栈顶元素。
10。TopologicalSort（）：输出G顶点的拓扑排序结果.有向图G采用邻接表存储结构.若G无回路，则输出G的顶点的一个拓扑序列并返回OK， 否则返回ERROR.
3。2 进制转换问题
主要流程图:
进制转换菜单:
1. void D_B（）: 十进制转换为二进制
for(j=0；a！=0;j++）
｛ p［j］=a％2; a=a/2；｝
printf（”\n转换后的数为："）；
for（k=j—1;k〉=0;k--)
｛printf(”%d”，p［k]）；}
printf（”\n”);
2. void D_O（）： 十进制转换为八进制
for（j=0;a！=0；j++)
{ p[j]=a％8;a=a/8；}
printf(”\n转换后的数为："）;
for(k=j—1；k〉=0；k-—）
｛printf(”％d"，p［k]）;｝
printf（"\n”）；
3. void D_X（）: 十进制转换为十六进制
for（j=0；a！=0；j++）
{p[j]=a％16；a=a/16;
if（p[j］〈10） p［j]+=48；
else
｛
switch（p[j］）
{
case 10: p［j］=’A'；break；
case 11: p［j]='B’；break;
case 12： p[j］='C'；break;
case 13： p［j］='D’；break；
case 14: p［j］=’E’;break；
case 15: p［j］=’F’；break;
}
｝
十进制转换为任意进制：
4. void B_D()： 二进制转换为十进制
for(i=1；a！=0;i*=2)
｛
if（a％10〉1)
{s=1;break；}
else
{result+=（a％10）*i；a=a/10;｝
｝
if（s==1)
printf(”您的输入有误!请重新输入\n”）;
else
printf（”\n转换后的数为：%d\n”，result);
5. void O_D()： 八进制转换为十进制
for（i=1;a！=0；i*=8）
｛
if(a％10〉7）
｛ s=1；break;｝
else
｛result+=（a％10）＊i；a=a/10;｝
｝
if（s==1）
printf（"您的输入有误！请重新输入\n")；
else
{
printf("\n转换后的数为：％d\n"，result）；
｝
任意进制转换为十进制:
6. void B_O（)： 二进制转换为八进制
for(i=1；a！=0；i*=2）
｛if（a％10>1){s=1;break;｝
else｛result+=(a%10）＊i；a=a/10；｝
｝
for（j=0；result！=0；j++)
｛p[j］=result%8;result=result/8;｝
if（s==1）
printf(”您的输入有误！请重新输入\n”)；
else
{printf("\n转换后的数为:"）;
for(k=j—1；k〉=0;k——）
{printf（”％d”,p[k］）；｝
printf（”\n")；
｝
7. void B_X（)： 二进制转换为十六进制
for（i=1;a！=0;i*=2）
｛if（a%10〉1）{s=1；break;｝
else｛result+=（a％10)＊i;a=a/10；}
｝
for(j=0;result!=0;j++）
｛p［j］=result%16;result=result/16；
if (p[j］〉10)
｛switch（p［j])
｛
case 10: p［j]='A’；break;
case 11: p[j］='B’；break；
case 12： p［j］='C’；break；
case 13： p［j]=’D’;break;
case 14： p［j］='E';break；
case 15: p[j］='F'；break；
｝
}
else p[j］+=48；
}
if(s==1)
printf（"您的输入有误！请重新输入\n”）；
else
｛
printf（"\n转换后的数为:”）；
for（k=j—1;k〉=0；k--）
｛printf("%c”，p[k］)；｝
printf（"\n”）;
}
8. void O_B（)： 八进制转换为二进制
for(i=1；a!=0;i＊=8)
{if(a％10〉7）
{ s=1；break; }
else
｛result+=(a％10)*i；a=a/10；}
｝
for(j=0;result！=0；j++）
｛p[j］=result％2;result=result/2;
｝
if（s==1)
printf（”您的输入有误!请重新输入\n”）；
else
{printf(”\n转换后的数为："）;
for（k=j—1;k〉=0；k—-）
｛printf("％d"，p［k］);｝
printf(”\n”）；
｝
9. void O_D()： 八进制转换为十进制
for（i=1;a!=0；i*=8)
｛
if（a％10〉7)
{ s=1；break；｝
else
{result+=（a％10)＊i；a=a/10;}
｝
if（s==1）
printf(”您的输入有误！请重新输入\n”)；
else
｛
printf（”\n转换后的数为:％d\n”，result）;
｝
10。void X_D（): 十六进制转换为十进制
for（i=0；i〈k；i++）
{ if（a［i］<=’9’&＆a［i]〉=’1’） ｛ b［i]=a[i]—48；｝
else
｛
switch(a［i]）
{
case ’A’： b[i］=10;break;
case ’B’: b[i］=11;break；
case ’C’： b［i]=12;break；
case 'D': b［i]=13;break；
case ’E'： b[i］=14；break;
case 'F’: b［i］=15；break;
case 'a’： b[i］=10;break；
case ’b’： b［i］=11;break;
case 'c'： b［i］=12；break；
case 'd'： b［i］=13;break;
case ’e’： b[i］=14；break；
case ’f': b［i］=15;break；
default: s=1；
｝
}
11。void O_X（）: 八进制转换为十六进制
for(i=1;a!=0；i＊=8)
｛if（a％10〉7）｛s=1;break；｝
else{result+=（a％10)*i；a=a/10; }
}
for(j=0;result!=0；j++）
｛p[j］=result％16；result=result/16；
if（p［j］〈10）
p[j]+=48；
else
｛
switch(p［j])
｛
case 10： p[j］=’A’;break；
case 11： p［j］=’B’；break；
case 12: p［j]='C’；break；
case 13： p[j］=’D’;break；
case 14： p[j］=’E’；break；
case 15： p［j］='F'；break;
｝
｝
12。void X_B（）： 十六进制转换为二进制
for（i=0;i<k；i++）
｛if(a［i］〈=’9’&&a［i]〉=’1’)
b［i]=a［i］-48;
else
｛
switch(a［i]）
{
case ’A’： b［i］=10；break；
case ’B’： b[i]=11;break；
case 'C'： b［i］=12；break；
case ’D': b［i]=13；break;
case 'E'： b［i]=14;break；
case 'F’： b［i]=15；break；
case ’a’: b［i]=10；break;
case 'b'： b［i］=11；break;
case ’c’: b［i］=12；break；
case ’d’： b[i]=13;break;
case ’e’： b［i］=14；break;
case ’f'： b［i］=15;break;
default: s=1;
｝
}
13。void X_D（)： 十六进制转换为十进制
for（i=0；i〈k;i++）
｛ if(a［i］〈='9'＆＆a［i］〉=’1’） ｛ b［i］=a[i]—48；}
else
｛
switch（a［i］)
｛
case 'A’： b［i］=10;break；
case ’B’： b［i］=11；break;
case ’C’: b［i］=12;break；
case ’D’： b［i]=13;break;
case ’E’： b［i］=14;break；
case ’F'： b［i］=15；break；
case 'a’： b［i］=10；break;
case ’b’: b[i]=11；break；
case 'c’: b［i]=12；break；
case ’d’： b［i］=13;break;
case ’e'： b［i］=14;break;
case ’f’： b[i]=15；break;
default: s=1；
｝
}
14。void X_O（): 十六进制转换为八进制
for（i=0；i<k；i++）
｛
if(a［i］<=’9’&＆a[i］>=’1’)b［i]=a[i］—48;
else
｛
switch（a[i］）
{
case ’A'： b［i］=10；break;
case ’B’: b[i］=11;break；
case ’C’： b［i］=12;break;
case ’D’： b［i]=13；break;
case ’E’: b［i]=14；break；
case ’F’： b[i］=15;break；
case ’a'： b[i］=10；break;
case ’b’: b［i］=11；break；
case ’c’： b［i］=12；break；
case 'd’: b［i]=13;break；
case ’e’： b［i］=14；break;
case 'f’: b[i］=15;break；
default： s=1；
}
其他进制间的转换：
4 调试与测试
4。1 教学计划编制问题调试结果
输入学期总数，输入学期学分的上限，输入教学计划的课程数,输入先修关系的边数，输入课程的代表值，输入课程的学分值（如图）
输入每条弧的弧尾和弧头(如图):
显示的课程计划如下：
4。2 进制转换问题调试结果
进入系统时的界面：
二进制转换为八进制：　
十进制转换为十六进制:
十六进制转换为十进制：
5 设计总结
我的收获
虽然在高中我们已经学了C语言,大一我们已经学习了C++语言，但是,直到本期我们才开设了数据结构这一门课程。这门课程让我们对程序的原理有了系统的认识.对以往模糊的经验，起了总结提升的作用.在学习了这门课程后，我们进行了一个星期的课程设计，以实践我们的学习内容.
在这次课程设计中，我被分配到了教学计划课程编制问题，开始感觉很难，因为我从未编写过如此复杂的程序.在多方查找资料并参考类似程序后,我大体将程序的构架描绘好了.一边对照着网上的资料，一边对程序进行修改补充，然后根据拟好的大纲进行编制。期间，我与其它同学进行了讨论和探究,对程序的细节问题和应用方面进行了探索，并解决了主要的问题,于是便着手写具体的程序。
由于老师要求我们编写600多行的代码，但是教学计划课程编制问题的代码不足，所以我又选择了一个课题——进制转换问题，我会选择这个课题是因为我觉得作为学计算机的我，应该要能更好的了解关于计算机方面的知识。
这次实验，我进行了大量的资料查阅,对所学知识进行复习.通过这些努力，我对算法有了更深入的理解,对编程的步骤，有了具体的体会。通过和同学的广泛交流,我体会到了合作的必要性及合作的优势.更重要的是,这个课题完全脱胎于实际问题，让我对计算机行业，充满了信心和自豪.
以往我们学的计算机知识一般停留在理论上，这让我们不太理解计算机的应用和前景，而较少注重我们对算法的实践锻炼.而这一次的实习既需要我们去联系理论,又需要我们去实践方法，很多东西看上去都学过,但是和实际联系才知道变通的艰难.纸上得来终觉浅,这是我这次实习的最大收获。这次的实验让我们知道该如何跨过实际和理论之间的鸿沟.
存在的问题
由于程序十分的复杂，遇到了很多常见的语法错误,及逻辑错误.这需要我们不断的调试分析。符号的格式之类，指针的用法,判断输入输出的条件都是十分容易出错的地方。在逐条排除，程序终于得以完成。这让我明白了,解决问题，要细心认真，集思广益,这样才能把问题解决。
虽然程序变出来了，但是我大量借鉴了别人的程序,中间有很多的程序段都是一知半解,虽然查阅了资料,但是毕竟不是自己思考出来的程序，又无法当面询问写出编程的人，所以对部分程序还存在问题，我会继续查询资料将目前不懂的内容弄清楚。
参考资料:数据结构（C++语言描述） 吉根林 陈波主编
C++语言教材
6 程序代码
教学计划编制问题:
#include<string。h〉
#include〈ctype。h>
＃include〈malloc。h> // malloc（）等
＃include〈limits。h〉 // INT_MAX等
＃include〈stdio.h> // EOF（=^Z或F6)，NULL
＃include〈stdlib.h〉 // atoi(）52
#include<io。h〉 // eof(）
＃include〈math.h〉 // floor(),ceil(），abs（）
#include〈process。h> // exit（)
＃include〈iostream。h〉 // cout，cin
// 函数结果状态代码
＃define TRUE 1
＃define FALSE 0
＃define OK 1
＃define ERROR 0
＃define INFEASIBLE -1
typedef int Status； // Status是函数的类型,其值是函数结果状态代码，如OK等 typedef int Boolean； // Boolean是布尔类型，其值是TRUE或FALSE
＃define MAX_NAME 10
/＊ 顶点字符串的最大长度*/
＃define MAXCLASS 100
int Z=0；
int X=0；
int xqzs，q=1,xfsx;
typedef int InfoType；
typedef char VertexType[MAX_NAME］; /＊ 字符串类型＊/
/＊ 图的邻接表存储表示＊/
＃define MAX_VERTEX_NUM 100
typedef enum{DG}GraphKind; /＊ ｛有向图,有向网,无向图,无向网｝ */
typedef struct ArcNode
｛
int adjvex； /＊ 该弧所指向的顶点的位置*/
struct ArcNode ＊nextarc; /＊ 指向下一条弧的指针＊/
InfoType *info； /* 网的权值指针）*/
｝ArcNode； /* 表结点＊/
typedef struct
｛
VertexType data; /＊ 顶点信息*/
ArcNode ＊firstarc； /* 第一个表结点的地址，指向第一条依附该顶点的弧的指针*/ }VNode,AdjList［MAX_VERTEX_NUM]; /＊ 头结点*/
typedef struct
｛
AdjList vertices，verticestwo；
int vexnum，arcnum； /＊ 图的当前顶点数和弧数*/
int kind； /＊ 图的种类标志＊/
｝ALGraph;
/* 图的邻接表存储的基本操作＊/
int LocateVex（ALGraph G,VertexType u)
{ /＊ 初始条件： 图G存在，u和G中顶点有相同特征＊/
/* 操作结果： 若G中存在顶点u,则返回该顶点在图中位置;否则返回—1 ＊/
int i;
for（i=0;i〈G.vexnum；++i）
if(strcmp(u，G.vertices[i]。data）==0）
return i;
return —1；
}
Status CreateGraph（ALGraph ＊G）
｛ /＊ 采用邻接表存储结构，构造没有相关信息的图G（用一个函数构造种图) ＊/ int i，j，k;
VertexType va,vb;
ArcNode ＊p；
printf（”请输入教学计划的课程数： ”）；
scanf（”％d”，&（＊G).vexnum）；
printf(”请输入拓扑排序所形成的课程先修关系的边数： "）；
scanf（”％d”，&(＊G)。arcnum）;
printf("请输入％d个课程的代表值(<％d个字符)：\n”，(*G)。vexnum,MAX_NAME)；
for（i=0;i〈（＊G).vexnum；++i） /＊ 构造顶点向量*/
｛
scanf（”％s"，（*G)。vertices［i］.data)；
(＊G）。vertices［i］。firstarc=NULL；
｝
printf（”请输入％d个课程的学分值（〈%d个字符）：\n"，（＊G）.vexnum，MAX_NAME);
for(i=0；i<(*G)。vexnum；++i) /* 构造顶点向量＊/
｛
scanf(”％s”，（＊G）。verticestwo[i].data）；
｝
printf("请顺序输入每条弧（边)的弧尾和弧头（以空格作为间隔）:\n”）;
for（k=0；k<（*G).arcnum；++k) /＊ 构造表结点链表＊/
｛
scanf（”％s％s",va,vb)；
i=LocateVex(＊G，va）； /＊ 弧尾＊/
j=LocateVex（＊G，vb)； /＊ 弧头＊/
p=（ArcNode＊)malloc(sizeof（ArcNode）)；
p-〉adjvex=j；
p—〉info=NULL; /＊ 图＊/
p-〉nextarc=（＊G)。vertices［i].firstarc; /＊ 插在表头＊/
（＊G）。vertices[i].firstarc=p;
}
return OK；
｝
void Display（ALGraph G）
{ /＊ 输出图的邻接矩阵G ＊/
int i;
ArcNode ＊p；
switch(G。kind）
{
case DG: printf(”有向图\n"）;
｝
printf（”％d个顶点：\n”,G。vexnum);
for（i=0;i〈G.vexnum;++i）
printf（”%s ”，G。vertices［i］.data）;
printf（”\n%d条弧(边):\n”,G。arcnum)；
for（i=0；i〈G.vexnum；i++）
｛
p=G.vertices［i］。firstarc;
while（p）
{
printf（"％s→％s ”，G.vertices[i］。data，G。vertices［p—〉adjvex］。data）；
p=p->nextarc；
｝
printf（”\n”）;
}
｝
void FindInDegree(ALGraph G，int indegree［］)
｛ /＊ 求顶点的入度,算法调用＊/
int i;
ArcNode *p；
for(i=0;i〈G.vexnum;i++）
indegree[i]=0； /＊ 赋初值*/
for（i=0；i<G。vexnum;i++）
｛
p=G.vertices［i］.firstarc；
while（p）
{
indegree［p—>adjvex］++;
p=p-〉nextarc；
｝
}
}
typedef int SElemType; /＊ 栈类型＊/
/＊栈的顺序存储表示*/
＃define STACK_INIT_SIZE 10 /＊ 存储空间初始分配量＊/
＃define STACKINCREMENT 2 /* 存储空间分配增量＊/
typedef struct SqStack
{
SElemType *base； /＊ 在栈构造之前和销毁之后，base的值为NULL */ SElemType *top； /＊ 栈顶指针*/
int stacksize； /＊ 当前已分配的存储空间，以元素为单位*/
}SqStack; /* 顺序栈＊/
/＊ 顺序栈的基本操作*/
Status InitStack（SqStack *S）
{ /* 构造一个空栈S ＊/
（*S).base=（SElemType ＊）
malloc（STACK_INIT_SIZE＊sizeof(SElemType）);
if（！(＊S)。base）
exit（OVERFLOW）； /＊ 存储分配失败＊/
（*S）。top=（*S）.base;
（＊S）。stacksize=STACK_INIT_SIZE；
return OK；
}
void ClearStack(SqStack *S) //清空栈的操作
｛
S—〉top=S—〉base;
}
Status StackEmpty（SqStack S）
｛ /* 若栈S为空栈，则返回TRUE,否则返回FALSE ＊/
if（S。top==S.base）
return TRUE；
else
return FALSE；
}
Status Pop（SqStack ＊S，SElemType *e)
｛ /＊ 若栈不空，则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR ＊/
if((＊S）.top==（*S）.base）
return ERROR；
＊e=＊—-(＊S).top；
return OK；
｝
Status Push(SqStack ＊S，SElemType e)
｛ /＊ 插入元素e为新的栈顶元素＊/
if(（＊S)。top—（＊S).base〉=（*S）.stacksize） /* 栈满，追加存储空间＊/
{
（＊S）.base=(SElemType*）realloc（（＊S）。base,((*S）。stacksize+STACKINCREMENT)＊sizeof(SElemType））；
if(!（＊S）。base）
exit（OVERFLOW）; /＊ 存储分配失败*/
(＊S）.top=(＊S)。base+（＊S).stacksize;
（＊S）.stacksize+=STACKINCREMENT;
｝
＊((*S）.top）++=e；
return OK；
｝
typedef int pathone[MAXCLASS]；
typedef int pathtwo［MAXCLASS］;
Status TopologicalSort（ALGraph G)
｛ /＊ 有向图G采用邻接表存储结构.若G无回路，则输出G的顶点的一个拓扑序列并返回OK， */
/＊ 否则返回ERROR。*/
int i,k，j=0,count,indegree［MAX_VERTEX_NUM]；
bool has=false;
SqStack S；
pathone a；
pathtwo b；
ArcNode ＊p;
FindInDegree（G，indegree）; /＊ 对各顶点求入度indegree［0..vernum—1] ＊/
InitStack（＆S）； /＊ 初始化栈*/
for(i=0；i〈G。vexnum；++i） /* 建零入度顶点栈S */
if（!indegree［i]）
｛
Push（&S,i）；
//cout〈〈＊G。vertices[i].data〈〈endl;
}
/* 入度为者进栈＊/
count=0; /* 对输出顶点计数＊/
while（！StackEmpty(S）)
{ /＊ 栈不空＊/
Pop(&S,＆i）；
a［i]=＊G.vertices［i］.data;
b[i]=*G.verticestwo[i]。data；
printf("课程%s→学分％s ”，G.vertices［i］。data，G.verticestwo[i］.data）； /＊ 输出i号顶点并计数*/
++count;
for（p=G。vertices［i］.firstarc；p；p=p—〉nextarc）
｛ /＊ 对i号顶点的每个邻接点的入度减*/
k=p—>adjvex；
if（!（——indegree［k］)) /＊ 若入度减为，则入栈*/
｛
Push(＆S，k);
//cout<<＊G。vertices［i］.data〈〈endl；
}
｝
｝
if(count<G.vexnum）
｛
printf（”此有向图有回路\n”）；
return ERROR；
｝
else
{
printf(”为一个拓扑序列.\n”）;
has=true；
｝
FindInDegree（G，indegree）; /＊ 对各顶点求入度indegree[0。。vernum-1］ ＊/
ClearStack（＆S）;
cout<〈”======================课程计划如下===============================”〈〈endl;
int qq=1； //学期数
int xxf；
while（qq〈=xqzs）
{
int result［20］；
int rtop=0；
int nn=0;
//int ccount=0;
// 学期学分计算
xxf=0；
for（i=0;i<G。vexnum；++i) /* 建零入度顶点栈S */
{
if（0==indegree[i］）
｛
Push（＆S，i)；
｝
｝
while（!StackEmpty（S））
｛
int bb；
Pop（&S，&i）;
bb=atoi（G。verticestwo[i].data)；
xxf=xxf+bb;
if(xxf〉xfsx）
｛
break;
｝
indegree［i]-—；
for（p=G。vertices[i］。firstarc；p;p=p-〉nextarc)
｛ /* 对