教学计划编制问题.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]=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｛
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
＃include〈malloc。h> // malloc（）等
＃include〈limits。h〉 // INT_MAX等
＃include〈stdio.h> // EOF（=^Z或F6)，NULL
＃include〈stdlib.h〉 // atoi(）52
#include // 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；iadjvex］++;
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(counthas=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