教学计划编制问题

第一篇：教学计划编制问题

目 录 课题需求描述..........................................2 1.1 教学计划编制问题..................................2 1.2 进制转换..........................................2 2 总体功能与数据结构设计.................................3 2.1 总体功能结构......................................3 2.2 数据结构设计......................................4 3 算法设计和程序设计....................................6 3.1 教学计划编制问题..................................6 3.2 进制转换问题......................................9 4 调试与测试...........................................23 4.1 教学计划编制问题调试结果.........................23 4.2 进制转换问题调试结果.............................25 5 设计总结.............................................27 6 程序代码.............................................29 课题需求描述

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表示，等等）。总体功能与数据结构设计

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.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转换后的数为：%dn”,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转换后的数为：%dn”,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转换后的数为：%dn”,result);}

10.void X_D()： 十六进制转换为十进制

for(i=0;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='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='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='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.1 教学计划编制问题调试结果

输入学期总数，输入学期学分的上限，输入教学计划的课程数，输入先修关系的边数，输入课程的代表值，输入课程的学分值（如图）

输入每条弧的弧尾和弧头（如图）：

显示的课程计划如下：

4.2 进制转换问题调试结果

进入系统时的界面：

二进制转换为八进制：

十进制转换为十六进制：

十六进制转换为十进制： 设计总结 我的收获

虽然在高中我们已经学了C语言，大一我们已经学习了C++语言，但是，直到本期我们才开设了数据结构这一门课程。这门课程让我们对程序的原理有了系统的认识。对以往模糊的经验，起了总结提升的作用。在学习了这门课程后，我们进行了一个星期的课程设计，以实践我们的学习内容。

在这次课程设计中，我被分配到了教学计划课程编制问题，开始感觉很难，因为我从未编写过如此复杂的程序。在多方查找资料并参考类似程序后，我大体将程序的构架描绘好了。一边对照着网上的资料，一边对程序进行修改补充，然后根据拟好的大纲进行编制。期间，我与其它同学进行了讨论和探究，对程序的细节问题和应用方面进行了探索，并解决了主要的问题，于是便着手写具体的程序。

由于老师要求我们编写600多行的代码，但是教学计划课程编制问题的代码不足，所以我又选择了一个课题——进制转换问题，我会选择这个课题是因为我觉得作为学计算机的我，应该要能更好的了解关于计算机方面的知识。

这次实验，我进行了大量的资料查阅，对所学知识进行复习。通过这些努力，我对算法有了更深入的理解，对编程的步骤，有了具体的体会。通过和同学的广泛交流，我体会到了合作的必要性及合作的优势。更重要的是，这个课题完全脱胎于实际问题，让我对计算机行业，充满了信心和自豪。

以往我们学的计算机知识一般停留在理论上，这让我们不太理解计算机的应用和前景，而较少注重我们对算法的实践锻炼。而这一次的实习既需要我们去联系理论，又需要我们去实践方法，很多东西看上去都学过，但是和实际联系才知道变通的艰难。纸上得来终觉浅，这是我这次实习的最大收获。这次的实验让我们知道该如何跨过实际和理论之间的鸿沟。

存在的问题

由于程序十分的复杂，遇到了很多常见的语法错误，及逻辑错误。这需要我们不断的调试分析。符号的格式之类，指针的用法，判断输入输出的条件都是十分容易出错的地方。在逐条排除，程序终于得以完成。这让我明白了，解决问题，要细心认真，集思广益，这样才能把问题解决。

虽然程序变出来了，但是我大量借鉴了别人的程序，中间有很多的程序段都是一知半解，虽然查阅了资料，但是毕竟不是自己思考出来的程序，又无法当面询问写出编程的人，所以对部分程序还存在问题，我会继续查询资料将目前不懂的内容弄清楚。

参考资料：数据结构（C++语言描述）吉根林 陈波主编 C++语言教材 程序代码

教学计划编制问题：

#include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL #include // atoi()52 #include // eof()#include // floor(),ceil(),abs()#include

// exit()#include // 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(用一个函数构造种图)*/ 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)/* 构造顶点向量*/ {

} printf(“请输入%d个课程的学分值(<%d个字符):n”,(*G).vexnum,MAX_NAME);for(i=0;i<(*G).vexnum;++i)/* 构造顶点向量*/ { } printf(“请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):n”);for(k=0;k<(*G).arcnum;++k)/* 构造表结点链表*/ {

}

scanf(“%s”,(*G).vertices[i].data);(*G).vertices[i].firstarc=NULL;scanf(“%s”,(*G).verticestwo[i].data);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

} printf(“n”);} } void FindInDegree(ALGraph G,int indegree[]){ /* 求顶点的入度，算法调用*/ int i;ArcNode *p;for(i=0;i

printf(“%s→%s ”,G.vertices[i].data,G.vertices[p->adjvex].data);p=p->nextarc;

indegree[i]=0;/* 赋初值*/ for(i=0;i

} } } 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;

indegree[p->adjvex]++;p=p->nextarc;

return OK;} void ClearStack(SqStack *S)//清空栈的操作 { S->top=S->base;} Status StackEmpty(SqStack S){ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */

} Status Pop(SqStack *S,SElemType *e){ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */

if((*S).top==(*S).base)return ERROR;if(S.top==S.base)else return FALSE;return TRUE;*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

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<

课

程

计

划===============================”<

如

下

while(qq<=xqzs){

int result[20];int rtop=0;int nn=0;//int ccount=0;// 学期学分计算

xxf=0;for(i=0;i

} 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){ } indegree[i]--;for(p=G.vertices[i].firstarc;p;p=p->nextarc){ /* 对i号顶点的每个邻接点的入度减*/ k=p->adjvex;indegree[k]--;

break;

/* if(!(--indegree[k]))若入度减为,则入栈 { Push(&S,k);}*/ } result[rtop]=i;rtop++;} cout<<“第”<

}

cout<<“课程”<

ALGraph f;printf(“以下为教学计划编制问题的求解过程:n”);printf(“请输入学期总数:”);scanf(“%d”,&xqzs);printf(“请输入学期的学分上限:”);scanf(“%d”,&xfsx);CreateGraph(&f);Display(f);TopologicalSort(f);

进制转换问题：

#include #include #include void D_B(int);void D_O(int);void D_X(int);void B_D(int);void B_O(int);void B_X(int);void O_B(int);void O_D(int);void O_X(int);void X_B(char r[],int k);void X_D(char r[],int k);void X_O(char r[],int k);void main(){ int i,j,k=0;int q;char r[10];

printf(“+===============+n”);printf(“| 欢 迎 使 用 进 制 转 换 程 序 |n”);

printf(“+===============+n”);

printf(“ 本 版 本 只 做 正 整 数 的 进 制 转 换！”);do { q=0;//fflush(stdin);printf(“n请选择需要被转换的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&i);switch(i){ case 1: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 1: printf(“n同进制之间不用转化！n”);q=1;break;case 2: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_O(k);q=1;break;case 3: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_D(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);B_X(k);q=1;break;case 0: printf(“谢谢使用！”);}

break;case 2: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 2: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_B(k);q=1;break;case 3: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_D(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);O_X(k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 3: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 3: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_B(k);q=1;break;

case 2: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_O(k);q=1;break;case 4: printf(“n请输入您想要转化的数：”);scanf(“%d”,&k);D_X(k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 4: printf(“n请选择转换后的进制:n1、二进制n2、八进制n3、十进制n4、十六进制n0、退出n”);printf(“请输入0~4:”);scanf(“%d”,&j);switch(j){ case 4: printf(“n同进制之间不用转化！n”);q=1;break;case 1: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r);for(k=0;;k++){if(r[k]=='')break;} X_B(r,k);q=1;break;case 2: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r);for(k=0;;k++){if(r[k]=='')break;X_O(r,k);q=1;break;case 3: printf(“n请输入您想要转化的数:”);fflush(stdin);gets(r);

for(k=0;;k++){if(r[k]=='')break;} X_D(r,k);q=1;break;case 0: printf(“谢谢使用！”);} break;case 0: printf(“n谢谢使用！n”);} }while(q==1);} void B_D(int a)///////以下为: 二进制转换为十进制,八进制,十六进制.{ int i,s=0;int result=0;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转换后的数为：%dn”,result);} void B_O(int a){

int i,j,k,s=0;int p[30];int result=0;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”);} } void B_X(int a){ int i,j,k,s=0;char p[30];int result=0;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”);} } void O_B(int a)///////以下为: 八进制转换为二进制,十进制,十六进制.{ int i,j,k,s=0;int result=0;int p[30];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”);} } void O_D(int a){ int i,s=0;int result=0;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转换后的数为：%dn”,result);} } void O_X(int a){ int i,j,k,s=0;char p[30];int result=0;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;

} } } if(s==1)printf(“您的输入有误！请重新输入n”);else { printf(“n转换后的数为：”);for(k=j-1;k>=0;k--){printf(“%c”,p[k]);} printf(“n”);} } void X_D(char a[],int k)///////以下为: 十六进制转换为十进制,二进制,八进制.{ int i,j,s=0;int result=0;int b[50];for(i=0;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;} } } for(i=1,j=k-1;j>=0;j--,i*=16){result+=b[j]*i;} if(s==1)printf(“您的输入有误！请重新输入n”);else {printf(“n转换后的数为：%d”,result);} } void X_B(char a[],int k){ int i,j,s=0;int result=0;int b[50];int p[30];for(i=0;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;} } } for(j=k-1,i=1;j>=0;j--,i*=16){result+=b[j]*i;} 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--)

第二篇：教学计划编制问题

背景

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

问题描述

若用有向网表示教学计划，其中顶点表示某门课程，有向边表示课程之间的先修关系（如果A课程是B课程的先修课程，那么A到B之间有一条有向边从A指向B）。试设计一个教学计划编制程序，获取一个不冲突的线性的课程教学流程。（课程线性排列，每门课上课时其先修课程已经被安排）。

一． 需求分析

1.顶点表示课程名称（包含学分信息），有向边表示课程之间的先修关系，用有向图实现这个教学计划编制问题。

2.采用广度优先的方法搜索每个节点是否有边通向该节点。3.对有向图实行拓扑排序

4.程序输出的拓扑排序就是其教学修读课程的序列 5.测试数据：

输入：请输入课程的数量和课程先后关系：6

每门课程的编号：001 002 003 004 005 006

先修课程编号（课程 课程）

001 002 001 003 002 003 002 004 003 005

004 006

005 006 输出：001 002 003 004 005 006 二． 概要设计

1.抽象数据类型：

由于课程之间存在明显的先后关系，采用拓扑排序进行教学计划的排序，而拓扑排序不直接输出课程信息，而采用队列实现课程信息的输出 拓扑图的ADT的定义： ADT Graph{ 数据对象：Subject是课程编号，是类型为char的二维数组

数据关系R：点a，b∈Graph，若点a到b有一条边，则arcs[a][b]=1;否则=0； 基本操作P：

void Adj(Graph &G,char *c1,char *c2)//建立邻接矩阵

int Locate(Graph G,char *c){//图G中查找元素c的位置 int Indegree(Graph G,int pos)//计算入度 void DeleteDegree(Graph &G,int pos)//删除一条边 队列的抽象数据类型定义： ADT Queue{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：Rl={|ai-1,ai∈D,i=2,…,n}

约定其中ai端为队列头，an端为队列尾。基本操作

void InitQueue(Queue &Q){//初始化队列

void EnQueue(Queue &Q,int e){//入队列

void DeQueue(Queue &Q,int &e){//出队列

bool EmptyQueue(Queue Q)//判断是否为空 void InitQueue(Queue &Q)操作结果：构造一个空队列Q void EnQueue(Queue &Q,Node e)初始条件：队列Q已存在

操作结果：插入元素e为Q的新的队尾元素 void DeQueue(Queue &Q,Node &e)初始条件：Q为非空队列

操作结果：删除Q的队头元素，并用e返回其值 } 2.算法的基本思想：

a.在有向图中选取一个入度为零的顶点并输出 b.删除该顶点及所有以它为尾的弧

c.重复a,b两步，知道所有节点均输出或者无度为零的节点结束。3.程序的流程

程序由四个模块组成：

（1）输入模块：从键盘键入课程编号和课程之间的先修关系（2）建立Graph模块：构建符合课程关系的有向图（3）排序模块：对有向图图进行拓扑排序（4）输出模块：输出拓扑序列

三、详细设计

物理数据类型

由于课程与课程之间存在先修关系，可以采用有向图来构建课程与课程之间的关系，用邻接矩阵来实现图，采用入度为零的广度优先搜索来实现拓扑排序，用队列的方式来实现广度优先搜索

typedef struct{

char Subject[MAX_VEX][5];//顶点向量

int arcs[MAX_VEX][MAX_VEX];//邻接矩阵

int vexnum,arcnum;//图的当前顶点数和弧数 }Graph;图的伪代码：

class Graph{

//图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点

string ch;

for(int i=0;i

cout<<“请输入课程”<

cin>>ch;

line[i].head->node=ch;

line[i].head->position=i;

} } void pushEdge(){ //读入边

string ch1,ch2;

int pos1,pos2;

for(int i=0;i

{

cout<<“请输入课程关系”<

cin>>ch1>>ch2;

for(int j=0;j

if(line[j].head->node==ch1)

pos1=j;

//找到该字母对应的位置

if(line[j].head->node==ch2){

pos2=line[j].head->position;

break;

}

}

line[pos1].insert(pos2,ch2);

} } typedef struct{

int *base;

int front;

int rear;

}Queue;拓扑排序的伪代码为：

void topsort(){

//拓扑排序

int i;

int *d=new int[numVertex];

for(i=0;i

d[i]=0;

//数组初始化

for(i=0;i

Node* p=line[i].head;

while(p->next!=NULL){

d[p->next->position]++;//计算每个点的入度

p=p->next;

} 用队列实现拓扑排序的伪代码：

int top=-1,m=0,j,k;

for(i=0;i

if(d[i]==0){

d[i]=top;

//找到第一个入度为0的点

top=i;

}

while(top!=-1){

j=top;

top=d[top];

cout<node<<“ ”;

m++;

Node* p=line[j].head;

while(p->next!=NULL){

k=p->next->position;

d[k]--;

//当起点被删除，时后面的点的入度-1

if(d[k]==0){

d[k]=top;

top=k;

}

p=p->next;

} 算法的具体步骤

void CreateUDN(Graph &G){//建立一个有向图

//输入课程总数

//输入每门课程的编号 //输入课程的先修关系 } bool TopSort(Graph &G){

//有向图G采用邻接表储存结构

//若G无回路，则输出G的顶点的一个top序列并返回ture，否则返回false //队列实现top序列的存储和输出 } 算法的时空分析 Top排序：

对有n个顶点和e条弧的有向图而言，将建立求各顶点的入度的时间复杂度为O(e)；建零入度定点站的时间复杂度为O(n)，在top排序过程中，若有向图无环，则每个顶点近义词栈，出一次栈，入度减1的操作在while语句中总共执行e次，所以，总的时间复

杂度为O(n+e)。输入输出格式：

输入：请输入课程的数量和课程先后关系的个数：6 课程先后关系课程：7 每门课程的编号：001 002 003 004 005 006 输入课程关系（课程 课程）001 002 001 003 002 003 002 004 003 005

004 006

005 006 输出：教学计划为001 002 003 004 005 006 实验结果截图：

附录（代码）#include #include using namespace std;class Node{//结点类 public:

string node;

int position;//位置

Node* next;

bool visit;//是否被访问

Node(){visit=false;next=NULL;position=0;node=' ';} };class Line{

//线性表类 public: int num;Node* head;Node* rear;Node* fence;Line(){num=0;head=fence=rear=new Node();}

void insert(int v,string ch){

//插入元素

Node* current=new Node();

current->node=ch;

current->position=v;

fence->next=current;

fence=current;

num++;} };class Graph{

//图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点

string ch;

for(int i=0;i

cout<<“请输入课程”<

cin>>ch;

line[i].head->node=ch;

line[i].head->position=i;

} } void pushEdge(){ //读入边

string ch1,ch2;

int pos1,pos2;

for(int i=0;i

{

cout<<“请输入课程关系”<

cin>>ch1>>ch2;

for(int j=0;j

if(line[j].head->node==ch1)

pos1=j;

//找到该字母对应的位置

if(line[j].head->node==ch2){

pos2=line[j].head->position;

break;

}

}

line[pos1].insert(pos2,ch2);

} }

void topsort(){

//拓扑排序

int i;

int *d=new int[numVertex];

for(i=0;i

d[i]=0;

//数组初始化

for(i=0;i

Node* p=line[i].head;

while(p->next!=NULL){

d[p->next->position]++;//计算每个点的入度

p=p->next;

}

} int top=-1,m=0,j,k;

for(i=0;i

if(d[i]==0){

d[i]=top;

//找到第一个入度为0的点

top=i;

}

while(top!=-1){

j=top;

top=d[top];

cout<node<<“ ”;

m++;

Node* p=line[j].head;

while(p->next!=NULL){

k=p->next->position;

d[k]--;

//当起点被删除，时后面的点的入度-1

if(d[k]==0){

d[k]=top;

top=k;

}

p=p->next;

}

}

}

cout<

if(m

//输出点的个数小于输入点的个数，不能完全遍历

cout<<“网络存在回路”<

delete []d;} };int main(){

int n,m;cout<<“请输入课程总数和课程先后关系的个数”<>n>>m;if((n<=0)||(m<=0)){cout<<“输入错误”<

G.pushVertex();G.pushEdge();G.topsort();system(“pause”);

return 0;} }

第三篇：数据结构实验报告十—教学计划编制问题

问题描述：

若用有向网表示教学计划，其中顶点表示某门课程，有向边表示课程之间的先修关系（如果A课程是B课程的先修课程，那么A到B之间有一条有向边从A指向B）。试设计一个教学计划编制程序，获取一个不冲突的线性的课程教学流程。（课程线性排列，每门课上课时其先修课程已经被安排）。

基本要求：

（1）输入参数：课程总数，每门课的课程号（固定占3位的字母数字串）和直接先修课的课程号。

（2）若根据输入条件问题无解，则报告适当的信息；否则将教学计划输出到用户指定的文件中。

一、需求分析：

本程序需要基于图的基本操作来实现

二、概要设计 ：

抽象数据类型 ：

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

算法的基本思想 ：

1、图的构建：

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

2、Topsort算法：

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

程序由三个模块组成：

输入模块： 读入图的信息（顶点和边，用线性表进行存储）。处理模块：topsort算法。输出模块：将结果输出。

三、详细设计

算法的具体步骤： class Node{//结点类 public: string node;int position;//位置 Node* next;bool visit;//是否被访问

Node(){visit=false;next=NULL;position=0;node=' ';} };class Line{ //线性表类 public: int num;Node* head;Node* rear;Node* fence;Line(){num=0;head=fence=rear=new Node();} void insert(int v,string ch){ //插入元素

Node* current=new Node();

current->node=ch;

current->position=v;

fence->next=current;

fence=current;

num++;} };class Graph{ //图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点

string ch;

for(int i=0;i

cout<<“请输入顶点”<

cin>>ch;

line[i].head->node=ch;

line[i].head->position=i;

} } void pushEdge(){ //读入边

string ch1,ch2;

int pos1,pos2;

for(int i=0;i

{

cout<<“请输入边”<

cin>>ch1>>ch2;

for(int j=0;j

if(line[j].head->node==ch1)

pos1=j;//找到该字母对应的位置

if(line[j].head->node==ch2){

pos2=line[j].head->position;

break;

}

}

line[pos1].insert(pos2,ch2);

} } void topsort(){ //拓扑排序

int i;

int *d=new int[numVertex];

for(i=0;i

d[i]=0;//数组初始化

for(i=0;i

Node* p=line[i].head;

while(p->next!=NULL){

d[p->next->position]++;//计算每个点的入度

p=p->next;

}

} int top=-1,m=0,j,k;

for(i=0;i

if(d[i]==0){

d[i]=top;//找到第一个入度为0的点

top=i;

}

while(top!=-1){ j=top;top=d[top];

cout<node<<“ ”;m++;

Node* p=line[j].head;

while(p->next!=NULL){

k=p->next->position;

d[k]--;//当起点被删除，时后面的点的入度-1

if(d[k]==0){

d[k]=top;

top=k;

}

p=p->next;

}

}

} cout<

cout<<“网络存在回路”<>n>>m;Graph G(n,m);G.pushVertex();G.pushEdge();G.topsort();system(“pause”);return 0;}

四、调试分析

略。

五、测试结果

本实验的测试结果截图如下：

注：此处由于不会用文件流输入和输出，故在命令提示符上直接进行输入。

六、用户使用说明（可选）

1、本程序的运行环境为windows 操作系统，执行文件为Untitled1.exe 2、运行程序时

提示输入数据 并且输入数据然后回车就可以继续输入相应数据，最后即可得到结果。

七、实验心得（可选）

1、本实验是在图的遍历问题的基础上做的，图的构建大部分是采用图 的遍历问题中的代码（不过要将结点类中的char改为string型），自己另外写了topsort函数，就完成了整个程序。

2、topsort函数中一开始采用的方法是找到一个入度为0的点，完成 相应的操作后，重新进行搜索，后来改进代码，先搜索入度为0的 点后面连接的点，这样减少了算法复杂度。

附录（实验代码）：

#include #include using namespace std;class Node{//结点类 public: string node;int position;//位置 Node* next;bool visit;//是否被访问

Node(){visit=false;next=NULL;position=0;node=' ';} };class Line{ //线性表类 public: int num;Node* head;Node* rear;Node* fence;Line(){num=0;head=fence=rear=new Node();} void insert(int v,string ch){ //插入元素

Node* current=new Node();

current->node=ch;

current->position=v;

fence->next=current;

fence=current;

num++;} };class Graph{ //图类 private: int numVertex;int numEdge;Line* line;public: Graph(int v,int e){numVertex=v;numEdge=e;line =new Line[v];} void pushVertex(){ //读入点

string ch;

for(int i=0;i

cout<<“请输入顶点”<

cin>>ch;

line[i].head->node=ch;

line[i].head->position=i;

} } void pushEdge(){ //读入边

string ch1,ch2;

int pos1,pos2;

for(int i=0;i

{

cout<<“请输入边”<

cin>>ch1>>ch2;

for(int j=0;j

if(line[j].head->node==ch1)

pos1=j;//找到该字母对应的位置

if(line[j].head->node==ch2){

pos2=line[j].head->position;

break;

}

}

line[pos1].insert(pos2,ch2);

} } void topsort(){ //拓扑排序

int i;

int *d=new int[numVertex];

for(i=0;i

d[i]=0;//数组初始化

for(i=0;i

Node* p=line[i].head;

while(p->next!=NULL){

d[p->next->position]++;//计算每个点的入度

p=p->next;

}

} int top=-1,m=0,j,k;

for(i=0;i

if(d[i]==0){

d[i]=top;//找到第一个入度为0的点

top=i;

}

while(top!=-1){ j=top;top=d[top];

cout<node<<“ ”;m++;

Node* p=line[j].head;

while(p->next!=NULL){

k=p->next->position;

d[k]--;//当起点被删除，时后面的点的入度-1

if(d[k]==0){

d[k]=top;

top=k;

}

p=p->next;

}

}

} cout<

cout<<“网络存在回路”<>n>>m;Graph G(n,m);G.pushVertex();G.pushEdge();G.topsort();system(“pause”);return 0;}

第四篇：教学计划编制源代码

#include #include #include #include #include #include

#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE-1 #define Status int #define Boolean int #define MAX_NAME 10 #define MAXCLASS 100 #define MAX_VERTEX_NUM 100 #define STUDY 1 #define NOTSTUDY 0 #define STACK_INIT_SIZE 10 #define STACKINCREMENT 2 typedef int SElemType;typedef struct SqStack {

SElemType *base;

SElemType *top;

int stacksize;}SqStack;typedef char VertexType[MAX_NAME];typedef struct ArcNode {

int adjvex;//该弧指向顶点的位置

struct ArcNode *nextarc;//指向下一条弧的指针 }ArcNode;typedef struct {

VertexType data;

int credit;

int state;

int indegree;

ArcNode *firstarc;//指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VERTEX_NUM];typedef struct {

AdjList vertices;

int vexnum,arcnum;

int kind;}ALGraph;int LocateVex(ALGraph G,VertexType u){

int i;

for(i=0;i

if(strcmp(u,G.vertices[i].data)==0)

return i;

return-1;} Status CreateGraph(ALGraph &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

{

scanf(“%s”,&G.vertices[i].data);

G.vertices[i].firstarc=NULL;

G.vertices[i].state=NOTSTUDY;

G.vertices[i].indegree=0;

}

printf(“请输入%d个课程的学分值(<%d个字符):n”,G.vexnum,MAX_NAME);

for(i=0;i

{

scanf(“%d”,&(G.vertices[i].credit));

}

printf(“请顺序输入每条弧(边)的弧头和弧尾(以空格作为间隔):n”);

for(k=0;k

{

scanf(“%s%s”,va,vb);

i=LocateVex(G,va);

j=LocateVex(G,vb);

p=(ArcNode*)malloc(sizeof(ArcNode));

p->adjvex=j;

p->nextarc=G.vertices[i].firstarc;

G.vertices[i].firstarc=p;

}

return OK;} Status Display(ALGraph G){

int i;

ArcNode *p;

printf(“%d个顶点：n”,G.vexnum);

for(i=0;i

printf(“%s”,G.vertices[i].data);

printf(“n%d条弧(边):n”,G.arcnum);

for(i=0;i

{

p=G.vertices[i].firstarc;

while(p!=NULL)

{

printf(“%s→%s ”,G.vertices[i].data,G.vertices[p->adjvex].data);

p=p->nextarc;

}

printf(“n”);

} } Status FindInDegree(ALGraph G,int indegree[]){

int i;

ArcNode *p;

for(i=0;i

indegree[i]=0;

for(i=0;i

{

p=G.vertices[i].firstarc;

while(p)

{

indegree[p->adjvex]++;

p=p->nextarc;

}

} } Status InitStack(SqStack *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;} Status StackEmpty(SqStack *S){

if((*S).top==(*S).base)

return TRUE;

else

return FALSE;} Status Pop(SqStack *S,SElemType *e){

if((*S).top==(*S).base)

return ERROR;

*e=*--(*S).top;

return OK;} Status Push(SqStack *S,SElemType 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;} Status TopologicalSort(ALGraph &G,int numterm,int upterm){

ArcNode *p;

SqStack S;

int indegree[MAX_VERTEX_NUM];//存放各节点的入度

int i,j, k, m,n,q;

int count;//课程编排数目计数器

int sumcredit;//每个学期的课程学分累加器

FindInDegree(G, indegree);

for(i=0;i

G.vertices[i].indegree=indegree[i];

InitStack(&S);

count=0;

k=0;

while((count!=G.vexnum)&&(k<=numterm))

{

sumcredit=0;

q=0;

for(i=0;i

if((G.vertices[i].indegree==0)&&(G.vertices[i].state==NOTSTUDY))

{

Push(&S,i);

G.vertices[i].state=STUDY;//避免入度为零节点重复入栈

}

if(!StackEmpty(&S)&&(q<=upterm))

{

k= k+1;

printf(“第%d个学期学的课程：”,k);

printf(“n”);

while((!StackEmpty(&S))&&(q

{

Pop(&S,&j);

q=q+1;

sumcredit=sumcredit+G.vertices[j].credit;

printf(“%s ”,G.vertices[j].data);

count++;

for(p=G.vertices[j].firstarc;p;p=p->nextarc)//对j号顶点每个邻接点的入度减一

G.vertices[p->adjvex].indegree--;

}

printf(“学分为：n”);

printf(“%dn”,sumcredit);

}

}

return OK;} Status TopologicalSort1(ALGraph G,int numterm,int uplcredit){

ArcNode *p;

SqStack S;

int indegree[MAX_VERTEX_NUM];//存放各节点的入度

int i,j, k, m,n;

int count;//课程编排数目计数器

int sumcredit;//每个学期的课程学分累加器

FindInDegree(G, indegree);

for(i=0;i

G.vertices[i].indegree=indegree[i];

InitStack(&S);

count=0;

k=0;

while(count!=G.vexnum && k<=numterm)

{

sumcredit=0;

for(i=0;i

if((G.vertices[i].indegree==0)&&(G.vertices[i].state==NOTSTUDY))

{

Push(&S,i);

G.vertices[i].state = STUDY;//避免入度为零节点重复入栈

}

if(!StackEmpty(&S)&&(sumcredit<=uplcredit))

{

k= k+1;

printf(“n”);

printf(“第%d个学期学得课程有:n”,k);

sumcredit=0;

while((!StackEmpty(&S))&&(sumcredit

{

Pop(&S,&j);

sumcredit=sumcredit+G.vertices[j].credit;

if(sumcredit<=uplcredit)

{

printf(“%s ”,G.vertices[j].data);

count++;

for(p=G.vertices[j].firstarc;p;p=p->nextarc)//对j号顶点每个邻接点的入度减一

G.vertices[p->adjvex].indegree--;

}

else

{

Push(&S,j);//将未输出的节点重新压入栈

count--;

}

}

printf(“n学分为：n”);

printf(“%dn”,sumcredit);

}

}

if(count==G.vexnum)

printf(“编排成功”);

else printf(“编排不成功”);} int main(){

int x,y,z;

ALGraph G;

printf(“以下为教学计划编制问题的求解过程:n”);

printf(“请输入学期总数:”);

scanf(“%d”,&x);

printf(“每学期课程上限:”);

scanf(“%d”,&y);

printf(“输入学分上限：”);

scanf(“%d”,&z);

CreateGraph(G);

Display(G);

TopologicalSort1(G,x,z);}

第五篇：施工进度计划编制

1.1 施工进度计划编制

为确保本工程按业主要求的工期竣工，我公司针对组织实施的各个环节，各方面给予高度重视，分别从前期准备、施工过程以及资金、技术、人员、组织管理、材料供应、机械设备等方面着手制订详细的资源供应保障计划与措施，并按工程项目排定工期，实行严格的计划控制，做到预控预测到位、资源配置合理，保障工程供给；做到项目安排合理，穿插有序，以确保整个施工计划的顺利完成。现将我公司的具体措施分述如下：

1.开工准备阶段保证措施：

中标后项目经理部主要人员马上到位，按职责分工，上岗工作。

现场安排具有丰富协调经验的专人积极配合业主做好前期工作，以保证工程按计划开工。

组织临时设施建设和相应的大型机械设备，按计划调往工地，投入生产，及时安排落实，为下部工序提供条件。

公司由一名副经理挂帅，主抓前期调配工作，按施工总进度计划安排工作，并制订详细的前期准备工作的调度计划。

设专人负责施工现场的“三通一平”工作。精心筹划施工平面布置图。合理的施工平面布置图对于顺利执行施工进度计划是非常重要的。反之，如果施工平面图设计不周或管理不当，都将导致施工现场的混乱，直接影响施工进度，劳动生产率和工程成本。

做好开工前的动员工作，提高参建人员的积极性和责任感。同时加强技术培训，以良好的状态投入到工程建设中去。

工程开工前，组织参与工程施工的相关专业工程师，由项目技术负责人牵头对项目各级管理人员进行集中培训，学习相关法律法规，学习国家、地方市颁布的新规范、新条例，学习针对本工程所确定的管理规定、施工工艺、施工方法，掌握施工管理、施工组织及施工技术的全部内容。项目管理人员再对其管辖范围内的劳务各工程处、专业施工队进行培训，以书面或口头交底方式，让劳务人员都能熟悉掌握各项管理制度，操作工艺等。在项目开工前，项目技术负责人应组织各专业工程师认真学习施工图纸，领会设计意图，同时各专业工程师找出各专业图纸中存在问题；另外各专业工程师相互集中、对照，对各专业之间打架、矛盾、不联贯之处予以指出。对图纸中存在的问题和施工中需要解决的问题，尽快组织图纸会审，做好开工前的准备工作，使其不影响工程进度。

2.施工过程控制措施 2.1建立完善的计划保证体系

建立完善的计划保证体系是掌握施工主动权、保证工程进度的关键一环。本项目的计划控制体系将以旬、月、季、年和总进度控制计划构成工期计划为主线，并由此产生出设计进度计划、供货商招标和进场计划、技术保障计划、材料供应计划质量检验和控制计划、安全防护计划及后勤保障等一系列计划，在各项工作中做到心中有数，并根据实际情况，随时进行调整、纠偏，使进度计划管理形成层次分明、深入全面、动态跟踪、行之有效、贯彻始终的制度。在施工中以总工期为目标，以阶段控制计划为保证，采取工期动态管理，使施工组织科学化，合理化，确保阶段计划按期或提前完成。

2.2实行全面计划管理，认真编制切实可行的工程总进度计划，相应的旬、月阶段施工作业计划，并对每个作业班组下达生产计划任务书，使施工生产上下协调，长、短期计划衔接，坚持日平衡，旬调度，确保月计划的实施，从而保证该工程总工期实现。

2.3设立施工工期进度奖与工期保证金制度。工期保证金层层分解到每个施工进度控制点，然后再分解到各个作业、工种、班组，以每日生产计划书为依据，根据每旬生产进度计划进行考核，完成生产计划班组给予奖励，完不成计划承担工期保证金，并且安排其他班组施工，确保当月生产施工进度按计划完成。

2.4加强施工进度计划执行和落实的调查

为了进行进度控制，在工程项目施工过程中必须定期或不定期地跟踪检查施工实际进度情况，及时收集施工进度信息，整理统计检查数据，用“前锋线”法比较实际进度和计划进度，对检查的结果作出及时处理。

2.5为保证总目标计划的实现，在计划实施过程中必须坚持计划工作的日保旬、旬保月、月保季、季保年。及时编制月(旬)计划，实施过程管理。同时应做好施工记录及施工进度统计表，为施工进度分析和调查提供信息。

2.6做好施工项目计划实施调度工作

施工中的调度是组织施工中各阶段，环节、专业和工种的相互配合，进度协调的指挥核心，也是施工进度计划顺利实施的重要手段，其主要任务是掌握计划实施情况，协调各方面关系，采取措施排除各种矛盾，加强薄弱环节管理，实现动态管理，保证完成作业计划和实现总进度目标。

调度工作一般采用调度会议或生产碰头会形式，汇报生产执行情况和存在的问题。由项目负责人主持共同研究分析计划提前或拖后的主要原因，及时调整人、财、物各种资源的平衡，采取相应的防范和保证措施，调整各薄弱环节，最后做出调度决策并贯彻执行。

2.7采用合理的方法及时调整施工进度计划

进度计划在实施过程中由于不可预见因素造成的工期延误或拖后。为了保证总计划目标的实现就必须对计划实施过程调整，具体方法采用改变某些工作之间的逻辑关系或缩短某些工作的持续时间。

2.8合理安排计划

依据合同总工期要求编排合理的总进度计划，对生产诸要素（人力、机具、材料）及各工种进行计划安排，在空间上按一定的位置，在时间上按先后顺序，在数量上按不同的比例，合理地组织起来，在统一指挥下，有序地进行，确保达到预定的目的。总进度控制计划由总承包依据与业主签订的施工承包合同，以整个工程为对象，综合考虑各方面的情况，对施工过程做出整体性的部署，确定主要施工阶段的开始时间及关键线路、工序，明确施工的主攻方向。分包商根据总进度计划要求，编制所施工专业的分部、分项工程进度计划，在工序的安排上服从施工总进度计划的要求和规定，时间上既保证又留有余地，确保施工总目标（合同工期）的实现。

2.9 进度控制会议制度（1）例会制度。

项目部定期召开计划会议，会议由项目经理主持，业主指定专业分包和劳务作业主管生产的负责人参加。主要是检查计划的执行情况，提出存在的问题。分析原因研究对策采取措施。

1）业主、监理、项目部随时召集并提前下达会议通知单。业主指定专业分包和各作业单位必须派符合资格的人参加，参加者将代表其决策者。

2）业主指定分包单位和各作业单位派出参加会议者不得随意迟到、早退或缺席，如有特殊情况，应提前请假，并委派相应资格人员参加。

（2）会议内容

1）工程进度分析。计划管理人员定期进行进度分析，掌握指标的完成情况是否影响总目标。劳动力和机械设备的投入是否满足施工进度的要求，通过分析、总结经验、暴露问题、找出原因、制定措施，确保进度计划的顺利进行。

2）下达施工任务指令。施工任务指令原则上由项目经理签发，主要是针对出现新情况利用签发指令的形式，取得短平快的效果，其次是对在穿插施工时，必须在规定的时间内完成，否则影响下道工序的施工计划。对不能按照指令完成任务的分包单位，所造成的一切损失由分包单位承担。

3）业主指定专业分包和各作业单位及时根据项目部的安排调整进度计划，并在进度上有任何提前及延误应及时向项目部进行说明。

3.施工各关键节点进度保证措施及抢工期措施：

由于本工程面积比较大，而且工期要求非常严格，要保证每个关键节点都按期完成，必须按照施工各阶段进度保证措施认真执行，狠抓落实，才能确保本工程的顺利进行。

然而由于施工生产中影响进度的因素纷繁复杂，如设计变更、技术、资金、机械、材料、人力、水电供应、气候、组织协调等等，仍不可避免会出现在某阶段暂时性的工期滞后，为了防止一步落后，步步落后的现象发生，保证目标总工期的实现，就必须采取各种措施预防和克服上述影响进度的诸多因素，为此，提出以下具有针对性的赶工措施。

3.1技术措施

1）首先必须组织工程技术人员和作业班长熟悉施工图纸，优化施工方案，为快速施工创造条件；制定各分部分项工程施工工艺及技术保障措施（如基础大体积砼施工及养护、地下防水、后浇带施工、高架支模施工、机电安装的施工技术措施），提前做好一切施工技术准备工作，从而保证严格按审定的进度计划实施。

2）积极引进、采用有利于保证质量，加快进度的新技术、新工艺，在本工程中除采用常用的商品泵送混凝土、粗直径钢筋直螺纹连接以外，着重考虑新工艺、新技术、新材料保证进度目标实现。

3）落实施工方案，在发生问题时，及时与设计、甲方、监理沟通，根据现场实际，寻求妥善处理方法，遇事不拖，及时解决，加快施工进度。

4）施工面积大的有利条件是作业面宽敞，在保证足够劳动力的前提下，进行作业分区管理，通过作业分区来缩小工程规模，组织小流水施工，可以缓解材料、机具调试等因素的影响，每个区段中合理组织、流水作业。

5）建立准确可靠的现场质量监督网络，加强质检控制，保证施工质量，做好成品保护措施，减少不必要的返工、返修，以质量保工期，加快施工进度。

6）施工班组人员多，所以每道工序施工前必须做好技术质量交底，制定详细而实施性强的保证各工序顺畅衔接，减少窝工，提高工效。

7）针对交叉作业多的情况，施工中统筹安排，合理安排工序之间的流水与搭接。8）实行进度计划的有效动态管理控制并适时调整，使周、月、季计划更具有现实性。以工程总体进度网络为纲，编制各施工阶段详细的实施计划，包括季度、月度、周计划，明确时间要求，据此向各作业队、班组下达任务。在安排施工进度时，各分部分项工程工作安排将根据实际情况，分别予以提前5%~10%，以确保工期目标的实现。并根据不同施工阶段及专业特点，把握施工周期中关键线路，决不允许关键线路上的工作事件被延误，对于非关键线路的工作，则可合理利用时差，在工作完成日期适当调整不影响计划工期的前提下，灵活安排施工机械和劳动力流水施工。做到重点突出，兼顾全局，紧张有序，忙而不乱。

3.2 经济措施

1）落实实现进度目标的保证资金，根据施工实际情况编制月进度报表，工程款做到专款专用，使之合理分配于人工费、材料费等各个方面，公司财务定期检查核实，从资金上保证工作能够顺利进行。

2）签订并实施关于工期和进度的经济承包责任制，包括公司与项目部，项目部与管理人员及班组，乃至作业班组与工人个人之间的责任状。

3）建立并实施关于工期和进度的奖惩制度，实行奖惩制度是项目管理上激励机制和制约机制的具体体现，根据招标文件业主承诺的工期奖罚额度以及项目部层层签订的责任状，层层落实，层层考核，层层兑现。并预先将奖金分解到各工种班组中去，在全体参施人员中牢固树立质量争第一进度更要第一的思想，通过对目标实现与否的重奖重罚增强项目部所有人员的责任心与积极性。

4）特殊时期还需考虑人工紧张劳动力增加费、停水停电机械租费等的资金储备。3.3 组织协调措施

1）建立施工项目进度实施和控制的组织系统及目标控制体系，实行以总承包项目经理为首的施工调度中心，强化总承包管理，将所有参与本工程施工的各专业力量拧成一股绳，控制在总承包的统一部署之下，及时同有关分项队组互通信息，掌握施工动态，协调内部各专业工种之间的工作，注意后续工序的准备，布置工序之间的交接，及时解决施工中出现的各类问题，促成各专业几近同步地完成各自的施工任务。并成立快速应变工作小组，发现问题，当场解决，不推不拖，化解矛盾，减少工期损失。

2）订立进度控制工作制度，在施工中，定期检查，随时监控施工过程的信息流，实现连续、动态的全过程进度目标控制，比照计划，分析进度执行情况，及时调整人力、物力、资金及机械的投入量。并及时总结前一段或借鉴兄弟单位的成功经验，不断改进优化施工工艺与程序，上下动员，齐心协力，出谋献策，共同把工作做到最好。

3）落实各层次进度控制人员的具体任务和工作职责，实行节日期间不停工，双休日、春节等国定假日实施轮休，合理安排班组工作作息，以经济嘉奖作为鼓励。重点部位进行不间断连续施工，主要施工人员日夜值班，采用二班或三班工作制。

4）重视现场协调会制度，分外联工程例会和内部工程例会两种形式。外联工程例会主要汇报工程进展情况，听取业主，监理、质检站及设计院等各方面的指导和意见，针对施工中的问题研讨处理方案措施，协调与业主外包专业工程施工单位的矛盾、协作关系；内部工程例会主要总结工程施工的进度、质量、安全情况，传达外联工程会议精神，明确各专业的施工顺序和工序穿叉的交接关系及责任，全面分析施工进度状况，找出问题根源，提出调整措施，加强各专业工种之间的协调、配合及工序交接管理，保证施工顺利进行。每周定期召开例会。

3.4 合同措施

1）供货、供电、运输、构件加工等合同规定的提供服务时间与有关的进度控制目标一致。

2）以上各种合同一经签订，便具有法律效力，明确各自在本工程中所应承担的义务，若有违反追究其违约的法律责任。3.5 施工机械配备

1）根据本工程特点，选用合理适用的施工机具，并在现场合理布置，以满足施工需要。

2）施工时可能会遇到断电或电压不足，在施工现场配备发电机组，随时备用。3）主体结构施工阶段的机械设备大部分与地下结构施工阶段相同，如起重机、混凝土输送泵、钢筋、模板加工机械、测量设备等均应按设备计划全部到位。

4）现场施工机械设备由专人负责操作，操作人员必须持证上岗作业。项目部组织技术精良的维修班组，严格按照机械操作规程及保养制度来进行保养和维修，保证其正常运转，充分发挥机械优势，确保工程的机械完好率达到90%以上，利用率达到95%以上。在机械首次使用前做好调试，施工间歇期，做好机械设备的维修保养工作，防止在施工中出现故障，影响工期。起重机等设备都按昼夜运转，机操工轮班作业，以充分发挥设备的效能。

3.6 材料计划

1）根据实际情况编制各项材料计划表，按计划分批进场，适应施工进度的需要，并根据计划落实各种工程材料、成品半成品等材料货源，以保证其相应的运作周期。

2）地方材料采购，充分做好市场调查工作，落实货源，确保工程对材料的需求。3）现场分别建立足够大的各种建材及周转材料储备仓库、堆场，防止灾害天气影响供货中断，保证工程正常施工。

4）随时了解材料供应动态，对缺口物资要做到心中有数，并积极协调，如对工程进度产生影响时，要提出调整局部进度计划和有效的补救措施，使总进度计划得以顺利实施。

5）根据不同的施工阶段要求，需业主、设计认可的材料、设备，在采购前提供样品及时确认，缩短不必要的非作业时间。

3.7 劳动力配置及保障措施

1）施工劳务层是施工过程的实际操作人员，是施工进度最直接的保证者，故我公司在选择劳务操作人员时的原则为具有较高的技术等级及有过类似工程施工经验的人员。

2）从劳务层的划分为三大类：第一类为专业化强的技术工种，其中包括机操工、机修工、架子工、维修电工、焊工、起重工等，这些人员均为我公司多次参与过类似工程的施工，具有丰富的经验，持有相应上岗操作证的人员。第二类为普通技术工种，其中包括木工、钢筋工、混凝土工、油漆工、粉刷工等；第三类为非技术工种，后二类人员的来源为长期与我公司合作的固定施工劳务队伍，素质好，信誉可靠。

3）对进场后的劳动力进行优化组合，使各施工区段上作业队的人员素质基本相当，采用齐头并进的作业思路，各工种提前做好准备，按进度及时插入，对于主体结构应注意安排好关键线路，对于大体积、大面积结构或必须连续施工的工作安排好加班作业人员和后继人员，为避免人员疲劳作业，实行轮班制，保证停人不停工。

4）农忙时季：在每年的秋收冬种时节，部分农村职工和民工将返回乡村播种庄稼。项目部将采取有效的经济手段和其他措施，动员农村职工在农忙季节坚守岗位，确保工程正常进展。

3.8 后勤保障

本项目在施工过程中将进行科学而人性化的管理，在抓进度赶工期的同时，认真仔细地做好各项后勤保障工作，使工人们能够安心愉快地投入工作，以提高工作效率。

1）特殊工种的手套、口罩、防护眼镜、安全带等劳保防护用品供应及时而到位。2）高温季节现场准备充足茶水供应。

3）冬季保证开水供应，雨季雨衣套鞋等劳保用品亦应充分。

4）在生活区设置必要的文娱设施，做到劳逸结合，调剂紧张的劳动生活。5）后勤服务人员要作好生活服务供应工作，重点抓好吃、住两大难题，食堂的饭菜要保证干净卫生且品种多、价格优，同时开饭时间要随时根据施工进度进行调整，晚上加班应备有夜餐。夏季温度较高的施工时段，安排有效的防暑、降温措施；冬季施工阶段，统一安装采暖空调，确保宿舍及办公环境的温暖舒适。