数据结构实验 教学计划编制问题
推荐第1篇：数据结构实验报告十—教学计划编制问题
问题描述：
若用有向网表示教学计划，其中顶点表示某门课程，有向边表示课程之间的先修关系（如果A课程是B课程的先修课程，那么A到B之间有一条有向边从A指向B）。试设计一个教学计划编制程序，获取一个不冲突的线性的课程教学流程。（课程线性排列，每门课上课时其先修课程已经被安排）。
基本要求：
（1） 输入参数：课程总数，每门课的课程号（固定占3位的字母数字串）和直接先修课的课程号。
（2） 若根据输入条件问题无解，则报告适当的信息；否则将教学计划输出到用户指定的文件中。
一、需求分析：
本程序需要基于图的基本操作来实现
二、概要设计 ：
抽象数据类型 ：
为实现上述功能需建立一个结点类，线性表类，图类。
算法的基本思想 ：
1、图的构建：
建立一个结点类，类的元素有字符型变量用来存储字母，整形变量用来存储位置，该类型的指针，指向下一个元素。建立一个线性表类，完成线性表的构建。建立一个图类，完成图的信息的读取，（如有n个点，则建立n个线性表，将每个结点与其指向的结点组成一个线性表，并记录线性表的长度）。
2、Topsort算法：
先计算每个点的入度，保存在数组中。找到第一个入度为0的点，将该点所连的各点的入度减一。再在这些点中找入度为0 的点。如果找到，重复上述操作。如果找不到，则跳出while循环，再搜索其他的点，看入度是否为0。再重复上述操作，如果所有的入度为0的点都被寻找到，但个数少于输入顶点的个数，说明该图存在环。 程序的流程
程序由三个模块组成：
输入模块： 读入图的信息（顶点和边，用线性表进行存储）。 处理模块：topsort算法。 输出模块：将结果输出。
三、详细设计
算法的具体步骤： cla Node{//结点类 public: string node; int position; //位置 Node* next; bool visit; //是否被访问
Node(){visit=false;next=NULL;position=0;node=\' \';} }; cla 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++; } }; cla 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];
coutnode
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; cla Node{//结点类 public: string node; int position; //位置 Node* next; bool visit; //是否被访问
Node(){visit=false;next=NULL;position=0;node=\' \';} }; cla 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++; } }; cla 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];
coutnode
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; }
推荐第2篇：数据结构实验教学
数据结构实验指导
说明：课内上机要求完成实验一到实验四的内容，并完成实验报告，实验报告在十七周星期三之前交，其他实验请大家课外抽时间完成。给出的示例程序供大家参考，大家实验的时候要自己动手编写程序，切不可完全照抄，每个实验具体的实验题目大家可以做示例的题目，也可以自己定一题目，只需用到该实验的知识点即可，编程语言大家可以选用自己熟悉的语言。
一．实验要求： 书写类C语言的算法，并将算法转变为程序实现。正确理解各种数据结构的逻辑特性和存储表示和基本操作的算法实现。针对问题的不同选择合适的数据结构，提高算法设计的能力和动手实验的技能。。 二．主要仪器设备：（所开实验的主要仪器设备）
硬件要求：在多媒体教室讲解及演示。为保证教学顺利进行，要求实验室提供PⅢ及以上的微机。
三、实验项目内容简介
为了达到实验目的，本课程安排了四个实习单元，训练的重点在于基本的数据结构，而不是强调面面俱到。各实习单元与教科书的各章只具有粗略的对应关系，一个实习题常常涉及到几部分教学内容。
1、线性表基本操作
（1) 熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现 （2)以线性表的各种操作（建立、插入、删除等）的实现为重点
（3) 通过本次实习帮助学生加深对高级语言C语言的使用（特别是函数参数、指针类型、链表的使用）。
2、栈、队列以及递归算法的设计
（1)掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们 （2) 训练的要点是“栈”的观点及其典型用法；问题求解的状态表示及其递归算法；由递归程序到非递归程序的转化方法
3、树、图及其应用
（1) 树和图是两种非线性数据结构，广义表的实质是树结构，而稀疏矩阵的十字链表存储结构也是图的一种存储结构，故本单元是本课的实习重点。
（2) 要求学生熟悉各种存储结构的特性，以及如何应用树和图结构求解具体问题。 （3) 训练的要点是：递归算法的设计方法；表达式的求值技术；哈夫曼方法及其编译码技术；完整的应用系统的用户界面设计和操作定义方法；矩阵乘法的特殊操作顺序；路径遍历（树、图的遍历）技术。
4、查找和排序
本次实习旨在集中对几个专门的问题做较为深入的探讨和理解
重点在掌握各种内部排序算法、查找算法的思想和实现。学生在实习中体会查找和内部排序算法思想，理解开发高效算法的可能性和寻找、构造高效算法的方法。
四、主要参考书
1、《数据结构题集》（C语言版）实习题部分，清华大学出版社,1999.11
2、《数据结构习题与解析》（C语言篇），李春葆 编著，清华大学出版社，2000.1
3、宁正元《数据结构习题解析与上机实验指导》
水利水电出版社（2003年）
实验一
线性表的操作
一、实验目的
1．熟悉C语言的上机环境，掌握C语言的基本结构。 2．会定义线性表的顺序存储结构。（链式存储结构） 3．熟悉对顺序表（单链表）的一些基本操作。
二、实验要求
1．认真阅读和掌握本实验内容所给的全部程序。 2．保存和打印出程序运行结果，并结合程序进行分析。 注意事项
在做第一次“数据结构”课程实验之前，要在硬盘上建立好自己的工作目录，专门来存储你所做的实验程序及相关信息，以后每次做实验都采用这个目录。
三、实验内容
1、示例（以顺序表为示例，同学们也可以编程实现单链表的创建、查找、插入、删除等功能）
以输入整形数据为主，输入后按“？”结束输入。
程序所能表达到的功能为：实现顺序表的创建、查找、插入、删除等功能。 程序运行后，输入数据并执行。 #include \"stdio.h\" #include \"conio.h\" #define MaxSize 50 typedef char elemtype; typedef struct node { elemtype data[MaxSize]; int len; }lnode,*List; void init(List L){ L->len=0;} int length(List L) { return L->len;} elemtype getnode(List L,int pos) { if(posL->len) printf(\"error\"); else return L->data[pos-1]; } int locate(List L,elemtype x) { int i=0; while(ilen && L->data[i]!=x) i++; if(i==L->len) return -1; else return(i+1); } void insert(List L,int pos,elemtype x) { int j; if(posL->len+1) printf(\"insert error\\n\"); else { L->len++; for(j=L->len;j>=pos;j--) L->data[j]=L->data[j-1]; L->data[pos-1]=x; }; } void delnode(List L,int pos) { int j; if(posL->len)printf(\"del error\\n\"); else { for(j=pos;jlen;j++) L->data[j-1]=L->data[j]; L->len--;} } void print(List L) { int i; for(i=1;ilen;i++) printf(\"%c->\",L->data[i-1]); printf(\"%c\",L->data[L->len-1]); } main() { int i=1,n; lnode L; char ch,x; init(&L); printf(\"\\n\\n\\n*******************************顺序表演示程序***********\\n\"); printf(\"请输入你想建立的顺序表的元素，以？结束:\"); ch=getchar(); while(ch!=\'?\') {insert(&L,i,ch); i++; ch=getchar(); }; printf(\"你建立的顺序表为:\"); print(&L); printf(\"\\n顺序表的长度为:%d\",L.len); printf(\"\\n输入你想查找的元素：\"); fflush(stdin); scanf(\"%c\",&x); printf(\"你查找的元素为%c序位为%d\",x,locate(&L,x)); printf(\"\\n输入你想查找的元素序位:\"); scanf(\"%d\",&n); printf(\"\\n你查找的元素为：%c\",getnode(&L,n)); printf(\"\\n输入你想插入的元素以及序位:\"); fflush(stdin); scanf(\"%c,%d\",&x,&n); insert(&L,n,x); printf(\"\\n插入后顺序表为：\"); print(&L); fflush(stdin); printf(\"\\n请输入你想删除的元素序位：\"); scanf(\"%d\",&n); delnode(&L,n); printf(\"\\n删除后的顺序表为：\"); print(&L); getch(); }
四、测试结果
运行程序，屏幕显示：“请输入你想建立的顺序表的元素，以？结束:” 输入：54381 你建立的顺序表为:5—>4—>3—>8—>1 顺序表的长度为:5 输入你想查找的元素：4 你查找的元素为4序位为2 输入你想查找的元素序位:4 你查找的元素为：8
输入你想插入的元素以及序位:\"：6，3 插入后顺序表为：5—>4—>6—>3—>8—>1 请输入你想删除的元素序位：5 删除后的顺序表为：5—>4—>6—>3—>1
实验二 二叉树的操作 一．实验目的
理解并熟悉掌握创建二叉树和实现二叉树的三种遍历 二．实验内容
创建二叉树和实现二叉树的三种遍历
根据提示输入字符型数据创建二叉树，输入值为所有字符型数据 输出为遍历后的每个结点的值的顺序
创建二叉树并能实现二叉树的先序、中序、后序遍历 如果输入数据为：a b c 输出结果为：a b c
b a c
b c a
程序流程：main()clrscr()createtree()preorder()inorder()postorder 源程序
#include \"stdlib.h\" struct tnode {char data; struct tnode*lchild; struct tnode*rchild; }; struct tnode tree;
void createtree(struct tnode*t) {struct tnode*p=t;
char check; if(p->lchild==NULL||p->rchild==NULL) /*判断左右子树是否为空*/
{printf(\"please enter the data:\");
scanf(\"%c\",&(p->data));
getchar();
}
/*输入根结点数据*/
/*创建函数*/
/*定义二叉树指针*/
/*引入头文件*/ /*定义二叉树存储结构*/
/*把二叉树指针给p*/ if(p->lchild==NULL)
{printf(\"%c leftchild is null.Add? y/n\\n\",p->data); /*左子树空，询问是否创建*/
scanf(\"%c\",&check);
getchar();
if(check==\'y\')
{struct tnode*q=(struct tnode*)malloc(sizeof(struct tnode)); /*开辟空间*/
q->lchild=NULL;
q->rchild=NULL;
p->lchild=q;
createtree(q);
}
} if(p->rchild==NULL)
{printf(\"%c rightchild is NULL.Add? y/n\\n\",p->data); /*右子树空，询问是否创建*/
scanf(\"%c\",&check);
getchar();
if(check==\'y\')
{struct tnode*q=(struct tnode*)malloc(sizeof(struct tnode)); /*开辟空间*/
q->lchild=NULL;
q->rchild=NULL;
p->rchild=q;
createtree(q);
}
} }
void preorder(struct tnode*t) {if(t)
{printf(\"%c \",t->data);
/*输出根结点数据*/
/*先序遍历函数*/
/*连到二叉树上*/
preorder(t->lchild);
preorder(t->rchild);
} }
void inorder(struct tnode*t) {if(t)
{inorder(t->lchild);
printf(\"%c \",t->data);
inorder(t->rchild);
} } void postorder(struct tnode*t) /*后序遍历函数*/ {if(t)
{
postorder(t->lchild);
postorder(t->rchild);
printf(\"%c \",t->data);
} }
void main() { clrscr();
/*清屏函数*/
/*左子树*/ /*右子树*/ /*创建二叉树*/
/*中序遍历函数*/ tree.lchild=NULL; tree.rchild=NULL; createtree(&tree);
preorder(&tree);
printf(\"\\n\"); inorder(&tree);
/*先序遍历*/
/*中序遍历*/ printf(\"\\n\"); postorder(&tree); }
三．使用说明
程序运行：
先输入根结点数据，例如：a 输入y或n判断是否创建左子树。输入y然后输入左子树数据 输入y或n判断是否创建右子树。输入y然后输入右子树数据 按回车可查看遍历结果并退出程序。
四．测试结果
运行程序，屏幕提示：
please enter the data:a
/*首先输入根结点，为a*/ a leftchild is null.add?y/n
/*询问是否输入a结点的左结点*/ y
/*输入*/ please enter the data:b
/*输入结点a的左结点，为b*/ b leftchild is null.add?y/n
/*询问是否输入b结点的左结点*/ n
/*不输入*/ b rightchild is null.add?y/n
/*询问是否输入b结点的右结点*/ n
/*不输入*/ a rightchild is null.add?y/n
/*询问是否输入a结点的右结点*/ y
/*输入*/ please enter the data:c
/*输入结点a的右结点，为c*/ c leftchild is null.add?y/n
/*询问是否输入c结点的左结点*/ n
/*不输入*/ c rightchild is null.add?y/n
/*询问是否输入c结点的右结点*/ n
/*不输入*/ 程序退出，显示结果应为：
a b c
/*先序*/
/*后序遍历*/
b a c
/*中序*/
b c a
/*后序*/
实验三
图的遍历操作
一．实验目的：
该实验主要完成对图的创建，并实现图的深度优先遍历和广度优先遍历 二．实验内容：
所输入的数据要为整形数据
输出的形式为：每按一次回车，遍历一个结点
能创建最大结点树为30的任意图，实现对无向图的两种遍历 程序流程：
main()clrscr()visited()DFS()visited()BFS() 源程序： #include #define maxvex 30 struct edgenode {int adjvex; char info; struct edgenode*next; }; struct vexnode {char data; struct edgenode*link; }; typedef struct vexnode adjlist[maxvex]; /*自定义adjlist为结构体数组类型*/ adjlist tu1;
void creategraph(adjlist g,int n) {int e,i,s,d;
/*图创建函数*/
/*定义存储边、点的变量*/ /*定义边的结构体指针*/ /*显示提示输入点，边*/
/*定义结构体数组变量tu1*/
/*定义点的结构体*/
/*引用两个头文件*/ /*定义MAXVEX=30*/
/*定义边的结构体*/ struct edgenode*p,*q;
printf(\"the point(n) and edge(e):\"); scanf(\"%d,%d\",&n,&e); for(i=1;i
{getchar();
/*接收点、边存入n,e中*/
/*提示输入结点信息*/ /*存储信息*/ /*最后指针为空*/
printf(\"\\tthe %d information:\",i);
scanf(\"%c\",&g[i].data);
g[i].link=NULL;
}
for(i=1;i
{printf(\"\\nthe%d edges=>\\n\\t :\",i);
scanf(\"%d,%d\",&s,&d);
/*提示输入边信息*/ /*接收边的信息*/
p=(struct edgenode*)malloc(sizeof(struct edgenode));
q=(struct edgenode*)malloc(sizeof(struct edgenode)); /*开辟两个存储边的空间*/
p->adjvex=d;
p->info=g[d].data;
q->adjvex=s;
q->info=g[s].data;
p->next=g[s].link;
g[s].link=p;
q->next=g[d].link;
g[d].link=q;
} }
int visited[maxvex];
/*定义访问数组*/
/*q和s的link指针连接起来*/ /*完成一个边的创建*/
/*p和s的link指针连接起来*/
/*把另一个点存储下来*/
/*把其中一个点存储下来*/ void dfs(adjlist adj,int v) {int i; struct edgenode*p; visited[v]=1;
/*深度优先遍历函数*/
/*定义边指针*/
/*把开始遍历的点在访问数组中标识*/
/*输出正访问的点*/ printf(\"now is at point %d\",v);
p=adj[v].link; printf(\"the data is %c \\n\",adj[v].data); getch(); while(p)
{if(visited[p->adjvex]==0)
dfs(adj,p->adjvex);
p=p->next;
} }
int quene[maxvex]; void bfs(adjlist adj,int vi) {int m=maxvex;
/*输出点的信息*/
/*没有访问的再调用DFS函数*/
/*访问过的判断下一个*/
/*广度优先遍历函数*/ /*定义一个队列*/ int front=0,rear=1,v; struct edgenode*p; visited[vi]=1;
/*定义边指针*/
/*开始访问的点标识一下*/
/*输出正访问的点*/ printf(\"now visit the point:%d\\n\",vi);
getch();quene[rear]=vi; while(front!=rear)
{front=(front+1)%m;
v=quene[front];
p=adj[v].link;
while(p)
{if(visited[p->adjvex]==0)
{visited[p->adjvex]=1;
/*把访问过的点放入数组中*/
/*判断p->adjvex点是否访问过*/ /*访问没有访问过的结点*/ printf(\"now visit the point:%d\\n\",p->adjvex); /*输出正访问的结点*/ getch();
rear=(rear+1)%m;
quene[rear]=p->adjvex;
}
p=p->next;
/*指向下一个*/
/*放入数组中*/
}
} }
void main() {int i;clrscr(); creategraph(tu1,0); for(i=1;i
visited[i]=0;
dfs(tu1,1);
getch();
/*访问数组初始化*/
/*调用DFS*/
/*创建图*/
/*等待输入*/
for(i=1;i
visited[i]=0; bfs(tu1,1);
} 三．使用说明：
根据屏幕上的英文提示先输入结点的个数和边数。然后输入各结点存储的信息，再输入定义的边，形成图。最后分别按照DFS深度优先遍历和BFS广度优先遍历实现对图的遍历。 四．测试结果： 运行程序，屏幕提示：
the point(n) and edge(e):4,3 /*输入顶点和边的数目*/ the 1 information:a
/*各个顶点的信息*/ the 2 information:b the 3 information:c the 4 information:d the 1 edges=>
/*各个边的连接情况*/ :1,2 the 2 edges=>:1,3 the 3 edges=>
/*调用BFS*/ :3,4
now is at point 1 the data is a /*深度优先遍历结果*/
now is at point 3 the data is c now is at point 4 the data is d now is at point 2 the data is b now visit the point:1
/*广度优先遍历结果*/ now visit the point:3 now visit the point:2 now visit the point:4
a b c d 实验四
栈的基本操作
一、实验目的：
1．熟练掌握栈的结构，以及这种数据结构的特点；
2． 能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法；
二、实验内容： 计算表达式的值 【问题描述】
计算用运算符后缀法表示的表达式的值。后缀表达式也称逆波兰表达式，比中缀表达式计算起来更方便简单些，中缀表达式要计算就存在着括号的匹配问题，所以在计算表达式值时一般都是先转换成后缀表达式，再用后缀法计算表达式的值。如：表达式(a+b*c)/d-e用后缀法表示应为abc*+d/e-。只考虑四则算术运算，且假设输入的操作数均为1位十进制数（0—9），并且输入的后缀形式表达式不含语法错误。 【数据描述】 #define add 43 /*运算符加号„+‟的ASCII码*/ #define subs 45 /*运算符减号„-‟的ASCII码*/ #define mult 42 #define div 47 /*运算符乘号„*‟的ASCII码*/ /*运算符除号„/‟的ASCII码*/ #define MAXSIZE 100 typedef struct{ { int stkdata[MAXSIZE];//用数组来表示栈空间，定义长度为MAXSIZE的栈
int top;
}STKzone; typedef STKzone *STK; typedef enum{true=1,false=0} bool; typedef enum{ok,error} status;
【C源程序】 #include #define add 43
/*运算符加号„+‟的ASCII码*/ //栈顶指针 #define subs 45
/*运算符减号„-‟的ASCII码*/ #define mult 42
/*运算符乘号„*‟的ASCII码*/ #define div 47
/*运算符除号„/‟的ASCII码*/ #define MAXSIZE 100 typedef struct { int stkdata[MAXSIZE];/*用数组来表示栈空间，定义长度为MAXSIZE的堆栈*/
int top; /*栈顶*/ }STKzone; typedef STKzone *STK; typedef enum{true=1,false=0} bool; typedef enum{ok,error} status; STKzone expSTKzone; STK expSTK; STK initSTK(STKzone *stack_zone){
/*执行栈初始化，建栈指针*/
STK p;
p=stack_zone;
p->top=0; } status push(int *term,STK pstk){ /*将一结构型数据送入栈中*/ if(pstk->top==MAXSIZE)
return error; /*栈满，进栈失败*/ pstk->stkdata[pstk->top] =*term; (pstk->top)++;/*栈顶指针移动*/ return ok; }/*push*/ bool emptySTK(STK pstk){ /*判断栈是否为空栈*/ return(pstk->top==0); } status pop(int *pdata, STK pstk){
/*从栈中取出一结构型数据*/ if(emptySTK(pstk))
return error; (pstk->top)--;/*退栈*/ *pdata =pstk->stkdata[pstk->top]; return ok; } void synerror() { printf(\"\\n表达式语法错！\"); exit(); } int eval(char tag,int a1,int a2) { switch(tag)
{ case add:return(a1+a2); case subs:return(a1-a2); case mult:return(a1*a2); case div:return(a1/a2); } } main() { char c;
int opd1,opd2,temp,c1;
expSTK=initSTK(&expSTKzone);
printf(\"\\n后置表达式: \");
while((c=getchar())!=\'\\n\')
{ if(c== \' \') continue; if((c>47)&&(c
{ putchar(c);
/*判断是否是0—9的字符*/ c1=c-48;
/*把输入的字符型数字转换成数字*/
if(push(&c1,expSTK)==error)/*运算分量进栈*/
{ printf(\"\\n表达式太长\\n\");
exit();} } else if((c==add)||(c==subs)||(c==mult)||(c==div))
{ putchar(c); if(pop(&opd1,expSTK)==error) /*将运算量1出栈*/ synerror();
if(pop(&opd2,expSTK)==error) /*将运算量2出栈*/ synerror();
}
else synerror();/*出现非法字符*/ }/*while*/ if(pop(&opd1,expSTK)==error) synerror(); if(!(emptySTK(expSTK))) synerror(); printf(“=%-3d\\n”,opd1); }/*main_end*/ 【测试数据】 输入: 23+↙
输出: =5
(即求2+3的结果) 输入: 145*+3/3-↙
输出: 4 (即求(1+4*5)/3-3的结果) 【说明】
本算法中对后置法表示的表达式求值按如下规则进行：自左向右扫描，每遇到一个`n+1元组（opd1,opd2,…,opdn,opr）(其中opd为操作数，opr为n元运算符)，就计算一次opr（opd1,opd2,…,opdn）的值，其结果取代原来表达式中n+1元组的位置，再从表达式开头重复上述过程，直到表达式中不含运算符为止。 temp=eval(c,opd2,opd1);/*计算得到结果*/ push(&temp,expSTK);/*将运算结果进栈*/ 【实验题】
1.假设一个算术表达式中包含零对到多对圆括弧，括弧对之间允许嵌套但不允许交叉，编写一个算法并上机实现：判断输入的表达式是否正确配对。Status correct(string expre)；//括弧配对正确，返回ok，否则返回error 2.3. 用栈实现一般表达式（即中缀表达式）到后缀表达式的转换。 数制转换。
实验五 数据查找
一．实验目的：
理解各种查找的思想，实现对数据的查找。例如用：直接查找法和折半查找法。 二．实验内容：
任意输入10个整形数据，然后再输入一个数据进行查找。 该程序能对输入的数据进行查找，然后把数据所在的位置输出。 例如：输入10个数据：12 3 4 5 6 7 8 9 1 2
输入查找数据：5 输出为：the 5 is at 4 position 源程序：
#include #include void seqsearch(int*,int); void binsearch(int*,int); void bubblesort(int*,int);
void menu() { printf(\" 1.seqsearch()\\n\"); printf(\" 2.binsearch()\\n\"); printf(\" 3.exit()\\n\"); printf(\"please select the method:\"); }
void main() {int i,j=1; int ch; int a[10];
/*声明插入查找函数*/ /*声明折半查找函数*/
/*声明起泡排序函数*/
/*引入头文件*/ clrscr(); printf(\"please input 10 data:\"); for(i=0;i
scanf(\"%d\",&(a[i]));
menu(); while(j)
/*接收输入*/
/*提示输入10个数据*/
/*显示菜单*/ /*循环一次*/ {scanf(\"%d\",&ch);
switch(ch)
{case 1:seqsearch(a,10);break;
case 2:binsearch(a,10);break;
case 3:j=0;break;
default:break;
}
printf(\"\\n\");
menu();
} }
void seqsearch(int*r,int n)
{int i=0,data; printf(\"please input find data:\");
scanf(\"%d\",&data);
while(r[i]!=data)
i++; if(i>n)
printf(\"the data is not found\");
else printf(\"the %d position is %d\",data,i+1); getch(); }
/*选择执行程序*/
/*直接查找函数*/
/*提示输入查找数据*/ /*接收数据*/
/*循环查找*/
/*输出数据没有找到*/
/*如果找到，输出位置*/
void binsearch(int *r,int n)
{int j,data,low=0,high=n,mid,find=0; bubblesort(r,n);
for(j=0;j
printf(\"%d \",r[j]);
printf(\"please input find data:\");
scanf(\"%d\",&data); while(low
{mid=(low+high)/2;
if(data
high=mid-1;
else if(data>r[mid])
low=mid+1; else find=1;
} if(!find)
printf(\"the data is not found!\\n\");
else printf(\"the data position is %d\",mid+1); getch(); }
void bubblesort(int *r,int n)
{int i,j,k,temp; k=n-1; for(j=0;j
{for(i=0;i
{if(r[i]>r[i+1])
{temp=r[i];
r[i]=r[i+1];
r[i+1]=temp;
/*折半查找函数*/
/*起泡法排序*/
/*排序后输出*/
/*提示输入查找数据*/
/*循环查找*/
/*置mid指针*/
/*判断数据大小，移动指针*/
/*显示数据没有找到*/
/*输出数据位置*/
/*起泡排序函数*/
/*比较大小*/
/*交换数据的位置*/
}
}
k=k-1;
} }
三．使用说明：
按提示输入10个任意的整形数据；输入要查找的数据；
可以看到所要查找的数据的位置。
四．测试结果： 运行程序，屏幕提示
please input 10 data:12 3 4 5 6 seqsearch()
binsearch()
exit please select the method:1
please input find data:5
the 5 is at 4 position
please select the method:2 please input find data:5 the 5 is at 4 position
7 8 9
2 /*输入10个数据*/ /*顺序查找*/ /*折半查找*/
/*选择顺序查找*/
/*输入要查找的数据*/
/*输出正确结果，并返回提示*/
实验六 哈希表设计
一．实验目的：
熟练掌握哈希表的构造方法，深刻理解哈希表与其他结构表的实质性差别。 二．实验内容：
程序的功能是对一批关键字集合采用除留余数法和线性探测再散列的方法解决冲突来建立相应的哈希表和完成查找过程及平均查找长度的计算。 【问题描述】
研究哈希（HAXI）表查找技术的两个重要问题是：构造HAXI函数和处理冲突。现在要求针对某个数据集合中的关键字设计一个哈希表（选择合适的哈希函数和处理冲突的方法），完成HAXI表的建立、查找，并计算HAXI表查找成功的平均查找长度。HAXI函数的构造方法有多种，其中除留余数法是一种最简单和最常用的方法。
考虑具体问题的关键字集合，如{19，14，23，1，68，20，84，27，55，11，10，79}这样一组数据和给定的哈希表长m 或哈希表的装填因子a，选用除留余数法和线性探测再散列技术解决冲突所形成的哈希表以及该哈希表在查找成功时的平均查找长度ASL。
【数据描述】
HAXI表是根据设定的HAXI函数和处理冲突的方法将一组关键字映射到一个有限的连续的地址区间上，并以关键字在地址区间的“象”作为记录在表中的存储位置。因此我们可以采用动态分配的顺序存储结构表示HAXI表。
typedef struct {
KeyType key ; }ElemType;
//元素类型的定义
ElemType *HAXI;//动态分配的哈希表的首地址
【算法描述】
1、选择合适的哈希函数H（ key）=key % p（P为小于或等于HAXI 表长的最大质数）；
2、计算各个关键字的直接哈希函数值；
3、根据处理冲突的方法建立哈希表，并输出；
4、在哈希表中进行查找，输出查找的结果，以及所需和记录关键字比较的次数，并计算和输出在等概率情况下查找成功的平均查找长度。
三、源程序 #include #include #define NULL 0 typedef int KeyType; typedef struct {
KeyType key ; }ElemType; int haxi(KeyType key,int m){ /*根据哈希表长m, 构造除留余数法的哈希函数haxi*/
int i,p,flag;
for (p=m ; p>=2 ; p--)
/*p为不超过m的最大素数*/
{ for (i=2,flag=1;i
if (p %i==0) flag=0;
if (flag==1) break;
} return key%p;
/*哈希函数*/ }
void inputdata(ElemType **ST,int n ){ /*从键盘输入n个数据，存入数据表ST（采用动态分配的数组空间）*/
KeyType key;
int i;
(*ST)=(ElemType*)malloc(n*sizeof(ElemType));
printf(\"\\nPlease input %d data:\",n);
for (i=0;i
scanf(\"%d\",&((*ST)[i].key)); }
void createhaxi(ElemType **HAXI,ElemType *ST,int n,int m){
/*根据数据表ST，构造哈希表HAXI*，n,m分别为数据集合ST和哈希表的长度*/ int i,j;
(*HAXI)=(ElemType*)malloc(m*sizeof(ElemType));
for (i=0;i
for (i=0;i
j=haxi(ST[i].key,m);
/*获得直接哈希地址*/
while ((*HAXI)[j].key!=NULL) j=(j+1)%m;/*用线性探测再散列技术确定存放位置*/
(*HAXI)[j].key=ST[i].key;
/*将元素存入哈希表的相应位置*/
} }
int search(ElemType *HAXI,KeyType key,int m,int *time){
/*在表长为m的哈希表中查找关键字等于key的元素，并用 time记录比较次数，
若查找成功，函数返回值为其在哈希表中的位置，否则返回-1*/ int i;
*time=1;
i=haxi(key,m);
while (HAXI[i].key!=0 && HAXI[i].key!=key) {i++; ++*time;}
if (HAXI[i].key==0) return -1;
else return i; } main(){
ElemType *ST,*HAXI;
KeyType key;
int i,n,m,stime,time;
char ch;
printf(\"\\nPlease input n && m(n
/*输入关键字集合元素个数和HAXI表长*/
scanf(\"%d%d\",&n,&m);
inputdata(&ST,n);
/*调用函数，输入n个数据*/
createhaxi(&HAXI,ST,n,m);
/*建立哈希表*/ /*输出已建立的哈希表*/
printf(\"\\nThe haxi Table is\\n\");
for (i=0;i
printf(\"\\n\");
for (i=0;i
/*哈希表的查找，可进行多次查找*/ do {
printf(\"\\nInput the key you want to search:\");
scanf(\"%d\",&key);
i=search(HAXI,key,m,&time);
if (i!=-1) {printf(\"\\nSucce,the position is %d \",i);/*查找成功*/
printf(\"\\nThe time of compare is %d\",time);
}
else{ printf(\"\\nUnsucce\");
/*查找失败*/
printf(\"\\nThe time of compare is %d\",time);
}
printf(\"\\nContinue(y/n):\\n\");
/*是否继续查找yes or no*/
ch=getch();
} while (ch==\'y\' || ch==\'Y\') ;
/*计算表在等概率情况下的平均查找长度，并输出*/
for (stime=0,i=0;i
search(HAXI,ST[i].key,m,&time);
stime+=time;
};
printf(\"\\nThe Average Search Length is%5.2f\",(float)stime/n);
ch=getch(); }
四、测试数据
按运行提示输入数据(关键字集合)ST，建立HAXI表，然后进行多次查找。 Please input n && m(n
0 1
7 14
68 27 55 19 20 84 Input the key you want to search:27 Succe,the position is 4 The time of compare is 4; Continue(y/n):y
Input the key you want to search:68 Succe,the position is 3 The time of compare is 1; Continue(y/n):n
The Average Search Length is 2.5
10 79 23
11 12
10 实验七 排序 一．实验目的：
理解各种排序的思想，实现对数据的排序。例如用：起泡排序和插入排序。 二．实验内容：
按提示输入10个整形数据。 每个数据中间一空格输出
程序达到的功能要求对输入的10个数据进行排序 例如：输入2 4 3 5 6 8 9 11 15 0
输出 0 2 3 4 5 6 8 9 11 15 源文件： #include #include void bubblesort(int[],int); void insertsort(int[],int);
void menu() {printf(\"
1.bubblesort()\\n\"); printf(\"
2.insertsort()\\n\"); printf(\"please select the method:\"); }
void main() {int i,j=1; int ch; int a[10]; clrscr(); printf(\"please input 10 data:\"); for(i=0;i
scanf(\"%d\",&a[i]);
/*显示提示输入10个数据*/ menu();
while(j--) {ch=getchar();
ch=getchar();
switch(ch)
{case\'1\':bubblesort(a,10);break;
case\'2\':insertsort(a,10);break;
} } for(i=0;i
printf(\"%d \",a[i]);
} void insertsort(int r[],int n)
{int i,j,temp1,temp2;
for(i=1;i
{temp1=r[i];j=i-1;
while(temp1=0)
{temp2=r[j+1];
r[j+1]=r[j];
r[j]=temp2;j--;
}
r[j+1]=temp1;
} }
void bubblesort(int r[],int n)
{int i,j,change,temp; for(i=n-1,change=1;i>=0&&change;--i)
{change=0;
for(j=0;j
/*显示菜单*/
/*选择排序方法*/
/*输出排序结果*/
/*插入排序函数定义*/ /*定义控制循环及中间变量*/
/*数据交换位置*/
/*起泡排序法函数定义*/
{if(r[j]>r[j+1])
/*数据交换位置*/
{temp=r[j+1]; r[j+1]=r[j]; r[j]=temp; change=1; }
}
} }
三．使用说明：
按提示输入10个整形数据 在菜单中选择排序的方法 查看排序结果
四．测试结果：
运行程序，屏幕提示
please input 10 data: 2 4 3 5 bubblesort() insertsort()
please select the method:1
0 2 3 4 5 6 8 9
please select the method:2
0 2 3 4 5 6 8 9
6 8 9 11 15 11 15 11 15 0
推荐第3篇：数据结构课程设计——教学计划编制
攀枝花学院课程设计论文 教学计划编制问题
摘 要
教学计划（课程计划）是课程设置的整体规划，它规定不同课程类型相互结构的方式，也规定了不同课程在管理学习方式的要求及其所占比例，同时，对学校的教学、生产劳动、课外活动等作出全面安排，具体规定了学校应设置的学科、课程开设的顺序及课时分配，并对学期、学年、假期进行划分。
根据一定的教育目的和培养目标制定的教学和教育工作的指导文件。它决定着教学内容总的方向和总的结构，并对有关学校的教学、教育活动，生产劳动和课外活动校外活动等各方面作出全面安排，具体规定一定学校的学科设置、各门学科的教学顺序、教学时数以及各种活动等。教学计划、教学大纲和教科书互相联系，共同反映教学内容。
近代以来，特别是在实行学科课程的条件下，教学计划主要是学科的计划，或只是学科表。随着社会经济和科学技术的新发展，教育结构不断发生变革，现代教育和教学理论主张对教学计划的结构实行改革。除了教学以外，生产劳动、科技活动、发展体力和增进健康的活动、艺术活动和社会活动等也应列入教学计划。下面就利用对此进行程序设计，已达到预期的目的。
关键字：数据结构，教学计划编制，抽象数据类型，程序设计
- 1攀枝花学院课程设计论文 教学计划编制问题
2.概要设计：
2.1流程图
void FindInDegree(ALGraph G, int indegree[])//求图中各节点的入度（如下左图）void CreatGraph(ALGraph *G)//构件图（如下右图）。
void TopologicalSort_1(ALGraph G,int numterm,int uplcredit) //有向图G采用邻接表存储结构(如下左图)；
void TopologicalSort_2(ALGraph G,int numterm,int uplcredit) //有向图G采用邻接表存储结构（如下右图）。
攀枝花学院课程设计论文 教学计划编制问题
主函数： void main()
- 4攀枝花学院课程设计论文 教学计划编制问题
数据关系:R1={﹤ai-1 ai﹥|ai-1,ai∈D,i=2,…,n} 基本操作: void InitStack (SqStack *S); int StackEmpty(SqStack S); void Push(SqStack *S, int ); int Pop(SqStack *S, int *e); }ADT Stack 2.3主程序
int main() //主函数 { int numterm; //学期总数
int uplcredit; //一个学期的学分上限 int selectway; ALGraph G; printf(\"请输入学期总数:\\n\"); scanf(\"%d\",&numterm); printf(\"请输入一个学期的学分上限:\\n\"); scanf(\"%d\",&uplcredit); CreatGraph(&G); printf(\"请选择编排策略:1.课程尽可能集中到前几个学期；2.课程尽量均匀分布\\n\"); scanf(\"%d\",&selectway); if(selectway==1) TopologicalSort_1(G,numterm,uplcredit); if(selectway==2) TopologicalSort_2(G,numterm,uplcredit); system(\"pause\"); return 0; } 2.4本程序只有两个模块,调用关系简单
主程序模块→拓扑排序模块
攀枝花学院课程设计论文 教学计划编制问题
4.详细设计
4.1头结点、表结点、邻接表的定义
#define MAX_VERTEX_NUM 100 //最大课程总数 typedef struct ArcNode{ int adjvex; struct ArcNode *nextarc; }ArcNode; typedef struct VNode{ char name[24]; //课程名 int claid; //课程号 int credit; //课程的学分 int indegree; //该结点的入度 int state; //该节点的状态
ArcNode *firstarc; //指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VEXTEX_NUM]; typedef struct{ AdjList vertices; int vexnum, arcnum; }ALGraph; 邻接表的基本操作：
void CreatGraph(ALGraph *); 创建邻接表
void FindInDegree(ALGraph , int * ); 求一个结点的入度
void TopologicalSort_1(ALGraph G,int numterm,int maxcredit); 拓扑排序来编排课程
void TopologicalSort_2(ALGraph G,int numterm,int maxcredit); 拓扑排序来编排课程
4.2栈的定义
#define STACk_INIT_SIZE 100 //存储空间的初时分配量 #define STACKINCREMENT 10 //存储空间的分配增量
- 789101112131415攀枝花学院课程设计论文 教学计划编制问题
6.调试分析
6.1实验过程中出现的问题及解决方法
我们在实验过程中遇到的最大难题是两个课程排序算法的编写。刚开始的时候没有任何的思路，网上也只有拓扑排序的算法，对于课程设计要求的排序算法没有任何头绪。经过请教老师和同学以及翻阅了一些相关书籍，并在网上的搜索有了排序算法的大体思路。经过三天的修改，终于写出了符合要求的排序算法。
6.2测试数据
学期总数：6；学分上限：10；该专业共开设12门课，课程号从01到12，学分顺序为2，3，4，3，2，3，4，4，7，5，2，3。
6.3测试结果（包含正确和错误的）
正确测试结果：
攀枝花学院课程设计论文 教学计划编制问题
错误测试结果：
攀枝花学院课程设计论文 教学计划编制问题
6.4测试数据及程序运行情况
输入的内容如下: 课程编号 课程名称 学分 先决条件 01 程序设计基础 2 无 02 离散数学 3 01 03 数据结构 4 01，02 04 汇编语言 3 01 05 语言的设计和分析 2 03，04 06 计算机原理 3 11 07 编译原理 4 05，03 08 操作系统 4 03，06 09 高等数学 7 无 10 线性代数 5 09 11 普通物理 2 09 12 数值分析 3 09，10，01 两种编排方法都输出结果为: 第一学期学的课程有:高等数学 程序设计基础； 第二学期学的课程有:普通物理 线性代数 汇编语言； 第三学期学的课程有:数值分析 计算机原理 离散数学； 第四学期学的课程有:数据结构；
攀枝花学院课程设计论文 教学计划编制问题
第五学期学的课程有:操作系统 语言的设计和分析； 第六学期学的课程有:编译原理。
7.实验分工
8.总结
刚开始学的时候确实有很多地方我很不理解，每次上课时老师都会给我们出不同的设计题目，对于我们一个初学者来说，无疑是一个具大的挑战，撞了几次壁之后，我决定静下心来，仔细去写程序。老师会给我们需要编程的内容一些讲解，顺着老师的思路，来完成自己的设计，我们可以开始运行自己的程序，可是好多处的错误让人看的可怕，还看不出到底是哪里出现了错误，但是程序还是得继续下去，我多次请教了老师和同学，逐渐能自己找出错误，并加以改正。经过了这次课程设计，现在已经可以了解很多错误在英文里的提示，这对我来说是一个突破性的进步，眼看着一个个错误通过自己的努力在我眼前消失，觉得很是开心。此次的程序设计能够成功，是我和我的同学三个人共同努力作用的结果。在这一段努力学习的过程中，我们的编程设计有了明显的提高。
其实现在想起来，收获还真是不少，虽然说以前非常不懂这门语言，在它上面花费了好多心血，觉得它很难，是需用花费了大量的时间编写出来的。现在真正的明白了一些代码的应用，每个程序都有一些共同点，通用的结构，相似的格式。同时也对教学编制问题有了进一步的认识。只要努力去学习，就会灵活的去应用它。
9.参考文献
［1］《数据结构》（C语言版），严蔚敏，清华大学出版社，2003。
攀枝花学院课程设计论文 教学计划编制问题
［2］《数据结构题集》，严蔚敏，清华大学出版社，2005。 ［3］《数据结构》（C语言版），刘大有，高等教育出版社，2004。 ［4］《Data Structure with C++》，William Ford．William Topp，清华大学出版社，2003。
推荐第4篇：教学计划编制问题
目 录
1 课题需求描述 ..........................................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 教学计划编制问题
大学的每个专业都要制订教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限均相等。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。在这样的前提下设计一个教学计划编制程序。通过输入实际的课程及先后关系。结合每学期的学分及课程数，制定好学习计划。在输入相关数据后，程序会安排好每学期的课程。
1.2 进制转换
进制数制是人们利用符号进行计数的科学方法。数制有很多种，在计算机中常用的数制有：十进制，二进制，八进制和十六进制。十六进制数有两个基本特点：它由十六个字符0~9以及A,B,C,D,E,F组成（它们分别表示十进制0~15），十六进制数运算规律逢十六进一。
要求： （1） 输入一个十进制数N,将它转换成R进制数输出，并可以进行你转换。
（2） 输入数据包含多个测试实例，每个测试实例包含两个整数N(32位整数)和R（2
（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]
十进制转换为任意进制：
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=\'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]
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; }
21
其他进制间的转换：
22
4 调试与测试
4.1 教学计划编制问题调试结果
输入学期总数，输入学期学分的上限，输入教学计划的课程数，输入先修关系的边数，输入课程的代表值，输入课程的学分值（如图）
23
输入每条弧的弧尾和弧头（如图）：
显示的课程计划如下：
24
4.2 进制转换问题调试结果
进入系统时的界面：
二进制转换为八进制：
25
十进制转换为十六进制：
十六进制转换为十进制：
26
5 设计总结 我的收获
虽然在高中我们已经学了C语言，大一我们已经学习了C++语言，但是，直到本期我们才开设了数据结构这一门课程。这门课程让我们对程序的原理有了系统的认识。对以往模糊的经验，起了总结提升的作用。在学习了这门课程后，我们进行了一个星期的课程设计，以实践我们的学习内容。
在这次课程设计中，我被分配到了教学计划课程编制问题，开始感觉很难，因为我从未编写过如此复杂的程序。在多方查找资料并参考类似程序后，我大体将程序的构架描绘好了。一边对照着网上的资料，一边对程序进行修改补充，然后根据拟好的大纲进行编制。期间，我与其它同学进行了讨论和探究，对程序的细节问题和应用方面进行了探索，并解决了主要的问题，于是便着手写具体的程序。
由于老师要求我们编写600多行的代码，但是教学计划课程编制问题的代码不足，所以我又选择了一个课题——进制转换问题，我会选择这个课题是因为我觉得作为学计算机的我，应该要能更好的了解关于计算机方面的知识。
这次实验，我进行了大量的资料查阅，对所学知识进行复习。通过这些努力，我对算法有了更深入的理解，对编程的步骤，有了具体的体会。通过和同学的广泛交流，我体会到了合作的必要性及合作的优势。更重要的是，这个课题完全脱胎于实际问题，让我对计算机行业，充满了信心和自豪。
以往我们学的计算机知识一般停留在理论上，这让我们不太理解计算机的应用和前景，而较少注重我们对算法的实践锻炼。而这一次的实习既需要我们去联系理论，又需要我们去实践方法，很多东西看上去都学过，但是和实际联系才知道变通的艰难。纸上得来终觉浅，这是我这次实习的最大收获。这次的实验让我们知道该如何跨过实际和理论之间的鸿沟。
27
存在的问题
由于程序十分的复杂，遇到了很多常见的语法错误，及逻辑错误。这需要我们不断的调试分析。符号的格式之类，指针的用法，判断输入输出的条件都是十分容易出错的地方。在逐条排除，程序终于得以完成。这让我明白了，解决问题，要细心认真，集思广益，这样才能把问题解决。
虽然程序变出来了，但是我大量借鉴了别人的程序，中间有很多的程序段都是一知半解，虽然查阅了资料，但是毕竟不是自己思考出来的程序，又无法当面询问写出编程的人，所以对部分程序还存在问题，我会继续查询资料将目前不懂的内容弄清楚。
参考资料：数据结构（C++语言描述） 吉根林 陈波主编 C++语言教材
28
6 程序代码
教学计划编制问题：
#include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL #include // atoi()52 #include // eof() #include // floor(),ceil(),abs() #include
29
#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
30
{ /* 采用邻接表存储结构,构造没有相关信息的图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
} printf(\"请输入%d个课程的学分值(<%d个字符):\\n\",(*G).vexnum,MAX_NAME); for(i=0;i
}
31 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
32 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;
33 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;
34
} *((*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;
35
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
课
程
计
划===============================\"
36
如
下
while(qq
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]--;
37 break;
/* if(!(--indegree[k])) 若入度减为,则入栈 { Push(&S,k); }*/ } result[rtop]=i; rtop++; } cout
}
38 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\");
39
printf(\" 本 版 本 只 做 正 整 数 的 进 制 转 换 ！ \"); do { q=0; //fflush(stdin); printf(\"\\n请选择需要被转换的进制:\\n
1、二进制\\n
2、八进制\\n
3、十进制\\n
4、十六进制\\n0、退出\\n\"); printf(\"请输入0~4:\"); scanf(\"%d\",&i); switch (i) { case 1: printf(\"\\n请选择转换后的进制:\\n
1、二进制\\n
2、八进制\\n
3、十进制\\n
4、十六进制\\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(\"谢谢使用！！\"); }
40
break; case 2: printf(\"\\n请选择转换后的进制:\\n
1、二进制\\n
2、八进制\\n
3、十进制\\n
4、十六进制\\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请选择转换后的进制:\\n
1、二进制\\n
2、八进制\\n
3、十进制\\n
4、十六进制\\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;
41
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请选择转换后的进制:\\n
1、二进制\\n
2、八进制\\n
3、十进制\\n
4、十六进制\\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]==\'\\0\') break;} X_B(r,k);q=1;break; case 2: printf(\"\\n请输入您想要转化的数:\"); fflush(stdin); gets(r); for(k=0;;k++) {if(r[k]==\'\\0\')break; X_O(r,k);q=1;break; case 3: printf(\"\\n请输入您想要转化的数:\"); fflush(stdin);gets(r);
42
for(k=0;;k++) {if(r[k]==\'\\0\')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转换后的数为：%d\\n\",result); } void B_O(int a) {
43
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;
44
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)
45
{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)
46
printf(\"您的输入有误！请重新输入\\n\"); else { printf(\"\\n转换后的数为：%d\\n\",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]
47
} } } 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;
48
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
49
{ 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--)
50
推荐第5篇：教学计划编制问题
背景
大学的每个专业都要制定教学计划。假设任何专业都有固定的学习年限，每学年含两学期，每学期的时间长度和学分上限值均相等。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。每门课程有哪些先修课程是确定的，可以有任意多门，也可以没有。每门课恰好占一个学期。试在这样的前提下设计一个教学计划编制程序。
问题描述
若用有向网表示教学计划，其中顶点表示某门课程，有向边表示课程之间的先修关系（如果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; 图的伪代码：
cla 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];
coutnode
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; cla Node{//结点类 public:
string node;
int position; //位置
Node* next;
bool visit; //是否被访问
Node(){visit=false;next=NULL;position=0;node=\' \';} }; cla 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++; } }; cla 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];
coutnode
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
G.pushVertex(); G.pushEdge(); G.topsort (); system(\"pause\");
return 0; } }
推荐第6篇：数据结构迷宫问题实验报告
《数据结构与算法设计》
迷宫问题实验报告
——实验二
专业：物联网工程 班级：物联网1班 学号：15180118 姓名：刘沛航
一、实验目的
本程序是利用非递归的方法求出一条走出迷宫的路径，并将路径输出。首先由用户输入一组二维数组来组成迷宫，确认后程序自动运行，当迷宫有完整路径可以通过时，以0和1所组成的迷宫形式输出，标记所走过的路径结束程序；当迷宫无路径时，提示输入错误结束程序。
二、实验内容
用一个m*m长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序对于任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。
三、程序设计
1、概要设计
（1） 设定栈的抽象数据类型定义
ADT Stack{
数据对象：D={ai|ai属于CharSet，i=
1、2…n，n>=0} 数据关系：R={|ai-1,ai属于D，i=2,3,…n} 基本操作： InitStack(&S)
操作结果：构造一个空栈 Push（&S，e）
初始条件：栈已经存在
操作结果：将e所指向的数据加入到栈s中 Pop（&S,&e）
初始条件：栈已经存在
操作结果：若栈不为空，用e返回栈顶元素，并删除栈顶元素 Getpop（&S，&e）
初始条件：栈已经存在
操作结果：若栈不为空，用e返回栈顶元 StackEmpty(&S)
初始条件：栈已经存在
操作结果：判断栈是否为空。若栈为空，返回1，否则返回0 Destroy(&S)
初始条件：栈已经存在
操作结果：销毁栈s }ADT Stack
（2）设定迷宫的抽象数据类型定义
ADT yanshu{
数据对象：D={ai,j|ai,j属于{‘ ’、‘*’、‘@’、‘#’},0
ROW={|ai-1,j,ai,j属于D，i=1,2,…M,j=0,1,…N} COL={|ai,j-1,ai,j属于D,i=0,1,…M，j=1,2,…N} 基本操作：
InitMaze(MazeType &maze, int a[][COL], int row, int col){
初始条件：二维数组int a[][COL],已经存在，其中第1至第m-1行，每行自第1到第n-1列的元素已经值，并以值0表示障碍，值1表示通路。
操作结果：构造迷宫的整形数组，以空白表示通路，字符‘0’表示障碍
在迷宫四周加上一圈障碍
MazePath（&maze）{
初始条件：迷宫maze已被赋值
操作结果：若迷宫maze中存在一条通路，则按如下规定改变maze的状态；以字符‘*’表示路径上的位置。字符‘@’表示‘死胡同’；否则迷宫的状态不变 }
PrintMaze（M）{ 初始条件：迷宫M已存在 操作结果：以字符形式输出迷宫 }
}ADTmaze
（3）本程序包括三个模块
a、主程序模块 void main() { 初始化； 构造迷宫； 迷宫求解； 迷宫输出； }
b、栈模块——实现栈的抽象数据类型 c、迷宫模块——实现迷宫的抽象数据类型
2、详细设计
（1）坐标位置类型：
typedef struct{ int row; //迷宫中的行 int col; //......的列
}PosType;//坐标
（2） 迷宫类型：
typedef struct{ int m,n; int arr[RANGE][RANGE]; }MazeType; //迷宫类型
void InitMaze(MazeType &maze, int a[][COL], int row, int col)\\ //设置迷宫的初值，包括边缘一圈的值
Bool MazePath(MazeType &maze,PosType start, PosType end) //求解迷宫maze中，从入口start到出口end的一条路径 //若存在，则返回true，否则返回false Void PrintMaze（MazeType maze） //将迷宫打印出来
（3） 栈类型：
typedef struct{ int step; //当前位置在路径上的\"序号\" PosType seat; //当前的坐标位置
DirectiveType di; //往下一个坐标位置的方向 }SElemType;//栈的元素类型
typedef struct{ SElemType *base; SElemType *top; int stacksize; }SqStack; 栈的基本操作设置如下： Void InitStack（SqStack & S）
//初始化，设S为空栈（S.top=NUL） Void DestroyStack(Stack &S) //销毁栈S，并释放空间
Void ClearStack（SqStack & S） //将栈S清空
Int StackLength（SqStack &S） //返回栈S的长度
Status StackEmpty（SqStack &S） ？、若S为空栈（S.top==NULL），则返回TRUE，否则返回FALSE Statue GetTop（SqStack &S，SElemType e）
//r若栈S不空，则以e待会栈顶元素并返回TRUE，否则返回FALSE Statue Pop(SqStack&S，SElemType e) //若分配空间成功，则在S的栈顶插入新的栈顶元素s并返回TRUE //否则栈不变，并返回FALSE Statue Push(SqStack&S，SElemType &e) //若分配空间程控，则删除栈顶并以e带回其值，则返回TRUE //否则返回FALSE Void StackTraverse（SqStack &S，Status）（*Visit）（SElemType e）） //从栈顶依次对S中的每个节点调用函数Visit 4求迷宫路径的伪码算法：
Status MazePath(MazeType &maze,PosType start, PosType end){ //求解迷宫maze中,从入口start到出口end的一条路径 InitStack(s); PosType curpos = start; int curstep = 1; //探索第一部 do{ if( Pa(maze,curpos) ){ //如果当前位置可以通过,即是未曾走到的通道块 FootPrint(maze,curpos); //留下足迹
e = CreateSElem(curstep,curpos,1); //创建元素 Push(s,e); if( PosEquare(curpos,end) ) return TRUE; curpos =NextPos(curpos,1); //获得下一节点:当前位置的东邻 curstep++; //探索下一步 }else{ //当前位置不能通过 if(!StackEmpty(s)){ Pop(s,e); while(e.di==4 && !StackEmpty(s) ){ MarkPrint(maze,e.seat); Pop(s,e); //留下不能通过的标记,并退回步 } if(e.di
curpos = NextPos(e.seat,e.di); //设定当前位置是该方向上的相块 }//if }//if }//else }while(!StackEmpty(s)); return FALSE; } //MazePath
四、程序调试分析
1.首先呢，想自己读入数据的，回来发现那样，很麻烦，所以还是事先定义一个迷宫。
2.栈的元素类型 一开始有点迷惑，后来就解决了
3.本题中三个主要算法；InitMaze，MazePath和PrintMaze的时间复杂度均为O（m*n）本题的空间复杂度也是O（m*n）
五、用户使用说明
1．本程序运行在windows系列的操作系统下，执行文件为：Maze_Test.exe。
六、程序运行结果
1.建立迷宫： 2．通过1功能建立8*8的迷宫后，通过2功能继续建立迷宫内部：
通过建立自己设定单元数目建立迷宫内墙。 3．通过3功能观察已建立的迷宫结构：
4．通过4功能确立迷宫起点和终点：
（此处像我们随机选择4,4和2,7分别为起点终点）
5．执行5功能，判断是否有路径走出迷宫：
这种情况无法走出迷宫。
我们再次观察图像设4,4和1,6分别为起点终点，再运行5功能。
观察到可以成功解开迷宫步数从1依次开始。
七、程序清单
#include #include #include #include // 迷宫坐标位置类型 typedef struct { int x; int y; }PosType; // 行值
// 列值
#define MAXLENGTH 25 // 设迷宫的最大行列为25
typedef int MazeType[MAXLENGTH][MAXLENGTH]; // 迷宫数组[行][列]
typedef struct // 栈的元素类型
{ int ord; // 通道块在路径上的＂序号＂
PosType seat; // 通道块在迷宫中的＂坐标位置＂
int di; // 从此通道块走向下一通道块的＂方向＂(0～3表示东～北) }SElemType;
// 全局变量
MazeType m; // 迷宫数组
int curstep=1; // 当前足迹,初值为1
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
// 栈的顺序存储表示
typedef struct SqStack { SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top;
int stacksize;
// 构造一个空栈S int InitStack(SqStack *S) { // 为栈底分配一个指定大小的存储空间
(*S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType)); if( !(*S).base )
(*S).top = (*S).base;
return 1;
// 栈底与栈顶相同表示一个空栈
(*S).stacksize = STACK_INIT_SIZE; exit(0); }SqStack; // 顺序栈
// 栈顶指针
// 当前已分配的存储空间，以元素为单位 }
// 若栈S为空栈（栈顶与栈底相同的），则返回1，否则返回0。 int StackEmpty(SqStack S) { if(S.top == S.base)
else
}
// 插入元素e为新的栈顶元素。 int Push(SqStack *S, SElemType e) { if((*S).top - (*S).base >= (*S).stacksize) // 栈满，追加存储空间
{
} *((*S).top)++=e; return 1; } // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回1；否则返回0。 int Pop(SqStack *S,SElemType *e) { if((*S).top == (*S).base)
左
return 1; } // 定义墙元素值为0,可通过路径为1,不能通过路径为-1,通过路径为足迹 // 当迷宫m的b点的序号为1(可通过路径)，return 1; 否则，return 0。 int Pa(PosType b) {
if(m[b.x][b.y]==1)
else return 0; return 1; return 0; *e = *--(*S).top;
// 这个等式的++ * 优先级相同，但是它们的运算方式，是自右向
(*S).base = (SElemType *)realloc((*S).base ,
(*S).top = (*S).base+(*S).stacksize; (*S).stacksize += STACKINCREMENT; ((*S).stacksize + STACKINCREMENT) * sizeof(SElemType)); exit(0); if( !(*S).base ) return 0; return 1; }
void FootPrint(PosType a)
// 使迷宫m的a点的序号变为足迹(curstep)，表示经过 { m[a.x][a.y]=curstep; }
// 根据当前位置及移动方向，返回下一位置
PosType NextPos(PosType c,int di) { PosType direc[4]={{0,1},{1,0},{0,-1},{-1,0}}; // {行增量,列增量}
// 移动方向,依次为东南西北
c.x+=direc[di].x; c.y+=direc[di].y; return c; }
// 使迷宫m的b点的序号变为-1(不能通过的路径) void MarkPrint(PosType b) {
m[b.x][b.y]=-1; } // 若迷宫maze中存在从入口start到出口end的通道，则求得一条
// 存放在栈中(从栈底到栈顶)，并返回1；否则返回0 int MazePath(PosType start,PosType end) {
SqStack S; PosType curpos; SElemType e;
InitStack(&S); curpos=start; do {
if(Pa(curpos)) {// 当前位置可以通过，即是未曾走到过的通道块
FootPrint(curpos); // 留下足迹
e.ord=curstep; e.seat.x=curpos.x; e.seat.y=curpos.y; e.di=0; Push(&S,e); // 入栈当前位置及状态
curstep++; // 足迹加1
if(curpos.x==end.x&&curpos.y==end.y) // 到达终点(出口)
} else return 1; curpos=NextPos(curpos,e.di); {// 当前位置不能通过
} if(!StackEmpty(S)) {
} Pop(&S,&e); // 退栈到前一位置
curstep--; while(e.di==3&&!StackEmpty(S)) // 前一位置处于最后一个方向(北) {
} if(e.di
}
e.di++; // 换下一个方向探索
Push(&S,e); curstep++;// 设定当前位置是该新方向上的相邻块 curpos=NextPos(e.seat,e.di);
MarkPrint(e.seat); // 留下不能通过的标记(-1) Pop(&S,&e); // 退回一步
curstep--; }while(!StackEmpty(S)); return 0; }
// 输出迷宫的结构
void Print(int x,int y) {
int i,j;
for(i=0;i
} }
void main() { PosType begin,end; int i,j,x,y,x1,y1,n,k; for(j=0;j
//清屏函数
printf(\"***************************************************\\n\\n\\n\"); printf(\"
1请输入迷宫的行数,列数\\n\"); printf(\"
2请输入迷宫内墙单元数\\n\"); printf(\"
3迷宫结构如下\\n\"); printf(\"
4输入迷宫的起点和终点\\n\"); printf(\"
5输出结果\\n\"); printf(\"
0退出\\n\"); printf(\"\\n\\n请选择
\"); scanf(\"%d\",&n); switch(n) { case 1:{
printf(\"请输入迷宫的行数,列数(包括外墙)：(空格隔开)\");
scanf(\"%d%d\", &x, &y);
for(j=1;j
{
for(i=1;i
for(j=1;j
// 迷宫左边列的周边即左边墙
m[j][y-1]=0;// 迷宫右边列的周边即右边墙
for(i=0;i
// 迷宫上面行的周边即上边墙
m[x-1][i]=0;// 迷宫下面行的周边即下边墙
物
联
网
1
班
-15180118-刘沛
航
}
}break;
case 2:
{printf(\"请输入迷宫内墙单元数：\");
scanf(\"%d\",&j);
printf(\"请依次输入迷宫内墙每个单元的行数,列数：(空格隔开)\\n\");
for(i=1;i
{ scanf(\"%d%d\",&x1,&y1);
} m[x1][y1]=0;
}break;
case 3:{ Print(x,y);printf(\"刘沛航建立的迷宫，定义墙元素值为0,可通过路径为1，输入0退出\");scanf(\"%d\",&k);}break;
case 4:{ printf(\"请输入起点的行数,列数：（空格隔开）\");
scanf(\"%d%d\",&begin.x,&begin.y);
printf(\"请输入终点的行数,列数：（空格隔开）\");
scanf(\"%d%d\",&end.x,&end.y);}break;
case 5:{
if(MazePath(begin,end)) // 求得一条通路
{
} else printf(\"此迷宫没有从入口到出口的路径，谢谢使用刘沛航的程序\\n\"); printf(\"输入0退出\");scanf(\"%d\",&k); }break; } }while(n!=0);} printf(\"此迷宫从入口到出口的一条路径如下，谢谢使用刘沛航的程序:\\n\"); Print(x,y); // 输出此通路
推荐第7篇：数据结构课程设计 舞伴问题
分类号编号
华北水利水电大学
North China Institute of Water Conservancy and Hydroelectric Power
课程设计
题目舞伴问题
院系信息工程学院 专业计算机科学与技术
姓名贾宁
指导教师杨彬
第一章需求分析 ........................................................................................................................2
1.1问题描述 ......................................................................................................................2 1.2 基本要求 .....................................................................................................................2
1.2.1 输入及输出格式 ..............................................................................................2 1.2.2 程序所完成的功能 ..........................................................................................2
第二章概要设计 ........................................................................................................................3
2.1 数据结构 .....................................................................................................................3 2.2 程序模块 .....................................................................................................................4 2.3 模块调用及算法 .........................................................................................................5 第三章详细设计 ........................................................................................................................7
3.1 操作实现 .............................................................................................................7 3.2 算法实现 .............................................................................................................8
第四章编码调试 ......................................................................................................................10
4.1 调试环境 ...................................................................................................................10 4.2 调试方法 ...................................................................................................................10 4.3 调试项目及调试结果 ...............................................................................................10
4.3.1 登陆测试 ........................................................................................................10 4.3.2 加载学生信息 ................................................................................................11 4.3.3 学生配对调试 ................................................................................................12 4.3.4 显示总配对 ....................................................................................................13 4.3.5 查询配对 ........................................................................................................13
第五章总结 ..............................................................................................................................15 参考文献 ..................................................................................................................................16 附录系统源代码 ......................................................................................................................17
第一章需求分析
1.1问题描述
一班有m个女生、n个男生(m不等于n), 举办一场舞会.男女生分别编号坐在舞池两边的椅子上，每曲开始时, 依次从男生和女生中各出一人配对跳舞, 本曲没成功配对者坐着等待下一曲找舞伴，设计一个程序模拟舞伴配对过程。
1.2 基本要求
1.2.1 输入及输出格式
输入男、女学生的姓名、性别，由程序自动为男女生编号，可以顺序编号，也可以随机编号，输出每曲配对情况（包括男、女生的姓名、性别和编号）。原始数据和结果数据要保存到文件中。在读入男女生信息时，可以从文件中直接读取学生的姓名和性别信息。
输出显示时显示每首歌的配对情况，包括对应配对学生的姓名、性别以及编号。可以输出整个舞池配对过程的所有配对情况。将输出显示的内容对应写入到指定的文件中。
1.2.2 程序所完成的功能
从文件或者手动输入班级的学生信息，包括姓名和性别基本信息，根据性别使男女生分别坐在舞池两边的座位上，学生的座位编号顺序生成，且一旦编号确定，将不再发生变化。
每一首歌曲播放时，依次从男女生队列中出来学生进行配对，由于男女生人数不一致，会使某个队列中剩下若干学生配对不成功，配对不成功者等待下首歌时再进行配对。该首歌结束时，配对成功的学生再回到座位上。然后再依次进行配对，未成功者等待下首歌再进行配对。
配对成功时，会显示本首歌的详细配对情况，以及整个过程的配对情况，并且可以将配对情况写入到文件。
根据男女生的姓名或者某首歌曲的名字可以查询到对应的配对情况。
第二章概要设计
2.1 数据结构
学生座位队列： ADT StuQueue{ 数据对象：D={ ai|ai∈ElemSet，i=1,2..n;n≥0 } 数据关系：R={ ai∈D ，i=1,2..n} voidInitQueue(StuQueue&Q) 操作结果：初始化一个空的循环队列 voidEnQueue(StuQueue&Q,FinalStustu) 初始条件：循环队列Q已经存在，并且无信息
操作结果：向Q中循环加入信息 void EnQueue2(StuQueue&Q,FinalStustu) 初始条件：循环队列已存在，非首次进循环队列
操作结果：向Q中添加信息
FinalStuDeQueue(StuQueue&Q) 初始条件：循环队列已存在
操作结果：使队列头的元素出队列，且返回FinalStu类型值 }ADT StuQueue //学生座位队列 音乐队列： ADTMusicList{ 数据对象：D={ ai|ai∈ElemSet，i=1,2..n;n≥0 }
数据关系：R={ ai∈D ，i=1,2..n} voidInitMusic(MusicList&MList) 操作结果：创建循环链表
voidInsertMusic(MusicList&MList,char* name) 初始条件：该链表已存在
操作结果：向链表中添加数据
3 }ADT MusicList；
临时队列： ADTTempQList{ 数据对象：D={ ai|ai∈ElemSet，i=1,2..n;n≥0 }
数据关系：R={ ai∈D ，i=1,2..n} void InitQList(TempQList&TQL) 操作结果：初始化临时队列
voidEnTempQueue(TempQList&TQL,FinalStustu) 初始条件：队列TQL已存在
操作结果：向TQL中添加信息 FinalStuDeTempQueue(TempQList&TQL) 初始条件：队列TQL存在
操作结果：取出队列的对头元素，返回FinalStu类型 }ADT TempQList；
2.2 程序模块
本系统主要包括登陆模块、学生入座、自动配对、显示配对过程以及查询配对信息模块。
登陆：输入正确的用户名以及密码，方可进入系统，连续输入错误三次则禁止进入系统。
学生入座：以不同的方式获取学生信息后，根据学生性别依次进入两个循环队列，并为每个学生唯一编号。
自动配对：每首歌开始时，男女生依次从坐席中出来进行本首歌的配对，配对不成功者等待下首歌继续配对，下首歌时，上首歌未配对成功者本首歌先进行配对。
显示配对过程：在播放歌曲的过程中，显示播放的歌曲信息，以及本首歌的配对信息。
查询配对：根据男女生的姓名查出两人的在哪一首歌进行过配对，根据歌曲名称查询出本首歌的配对信息。
4 文件操作：将配对情况及学生的座位信息写入文件 根据系统模块的划分，本系统的功能模块图如图2-1所示
舞池配对系统登陆学生入座自动配对显示配对过程查询配对结果
图 2-1 功能模块
2.3 模块调用及算法
登陆成功后进入主界面，进入主界面后，需要先运行学生入座模块，方能进行下边的操作。学生入座后会得到相关的基本信息。之后调用配对模块函数，进行学生的配对。学生配对成功后，才能利用显示配对过程进行显示配对的情况，后续的查询配对模块也必须在配对成功的基础上进行。模块间的调用流程如图2-2所示
主函数登陆函数入座模块配对模块显示配对查询结果 图 2-2 模块调用
5 在进行配对过程中用到算法，在每首歌配对时，依次从男女生队列中出来一个学生，进入到临时队列，从临时队列中获取配对的情况。在本首歌结束，下首歌开始之前，让临时队列中的男女在分别根据性别入队，依次循环，每次调用配对函数，实现学生的循环配对。
第三章详细设计
3.1 操作实现
本系统包含七个文件。设计分有欢迎界面，登陆系统，入队函数，配对函数，显示函数，查询函数等。登陆界面是整个系统的入口，其主要是让合法人员进入系统，入队函数主要让学生进入男女队列，配对函数主要是根据每首歌曲把男女生进行配对，显示函数主要是显示男女生的配对情况，查询函数主要是根据男女生姓名和歌曲名查找配对情况。
系统首先通过程序调用void main()进入欢迎界面和系统登陆界面，根据用户的帐号和密码登陆成功后进入主菜单。根据用户的选择可分别进入：1.学生就坐；2.每曲配对；3.显示结果；4.查询配对；5.退出。
选择“1.学生就坐”项，会显示学生信息来源，包括“1.按班级获取(推荐)”“2.手动输入...”两项可供选择。其中，1是从文件中获取学生信息，2是用户手动输入学生信息。
选择“2.每曲配对”项，会显示播放歌曲的类型，有“1.流行”“2.复古”两个音乐风格可供选择，当用户选择其中一个风格并确定播放后，会显示出当前播放的歌曲名字和所配对的男女生。
选择“3.显示结果”项，会有“1.学生座位信息”和“2.学生配对信息”两项操作可供选择。当选择1，会把学生就坐后的信息显示出来，选择2，会把每首歌学生的配对情况显示出来。
选择“4.查询配对”项，也有两个操作可供选择，分别是“1.按学生姓名”“按歌曲名”两项。选择1，会根据用户输入的男女生姓名查看他们的配对情况，选择2，会根据用户输入的歌曲名称显示每首歌曲学生的配对情况。
选择“5.退出”项，会出现感谢使用系统界面，并按任意键退出系统。 本系统的主流程图如图3-1 所示
开始欢迎和登陆界面主界面1 ？NN2 ？N3 ？N4 ？N5 ？Y结束程序Y学生就坐Y每曲配对Y每曲配对显示Y查询配对情况
图 3-1 主流程
3.2 算法实现
定义学生结构体FinalStu ，将学生的信息放到本结构体中，定义两个循环队列Boys和Girls队列，分别存储男女生的座位信息。定义MusicList循环链表，用于存放音乐信息。定义TempQueue队列，用于临时存放从男女生队列中出来的学生信息。创建一个存放每首歌配对情况的数组stuTable[]，用来存放播放该首歌曲时男女生的信息。
每一首歌开始时，男女生依次用Boys和Girls队列中出对，依次进入临时队列TempQueue，从TempQueue中读取男女生的信息，放到stuTable数组中，表示该首歌的 8 配对情况。下首歌开始时，让临时队列中的学生再根据性别依次进入男女循环队列。同时将存放歌曲的MusicList循环链表指针后移，播放下首歌曲，再执行上述操作，便可实现循环配对。
第四章编码调试
4.1 调试环境
硬件环境：Intel 1GHZ处理器（或AMD同类处理器），512M或以上内存容量，10G或以上硬盘容量,可连接互联网的相关设备。
软件环境（软件、操作系统）：Windows XP（或Windows 2003或Windows vista或Windows 7）操作系统，Microsoft Visual Studio 2008。
4.2 调试方法
为了提高测试效率，降低测试成本，本测试方案采用黑盒法设计基本的测试方案，再用白盒法补充一些方案。在黑盒法测试方案中，采用等价划分技术，把所有可能的数据划分成几个等价类。
4.3 调试项目及调试结果
4.3.1 登陆测试
用户根据用户名及密码登陆系统，内置用户为Admin，密码为888888。登陆成功如图4-1所示，登陆失败如图4-2所示
图 4-1 登陆成功
图 4-2 登陆失败
4.3.2 加载学生信息
可以从文件或者手动输入学生信息，从文件中选择时，可以选择不同的文件，其运行结果如图4-2 及图4-3 所示
图 4-3 选择信息来源
图 4-4 显示获取信息
11 4.3.3 学生配对调试
在进行配对之前，需要先将音乐信息加载到系统中，其加载过程如图4-5所示
图 4-5 加载音乐
学生就位及音乐加载成功后，开始播放音乐，并进行配对，其音乐播放情况及每首歌曲的配对情况如图4-
6、图4-7及图4-8所示
图 4-6 配对开始
图 4-7 播放下一首
图 4-8 循环配对
4.3.4 显示总配对
在整个过程结束后，停止播放音乐，可以显示整个过程的配对情况，其结果如图4-9所示
图 4-9 显示配对结果
4.3.5 查询配对
可以根据男女生的姓名查询两人的配对情况，当输入两个学生姓名时，显示在整个过程中的配对情况，其结果如图 4-10所示
图4-10 姓名查询配对
根据每一首歌曲情况查询在本首歌曲中的配对情况，其结果如图4-11 所示
图 4-11 按歌名查找
第五章总结
这次的课程设计懂得了理论与实际相结合是很非常重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为，从而提高自己的实际动手能力和独立思考的能力。在整个设计过程中，构思是很花费时间的，在构思总体架构时，需要先将需求分析搞清楚，需要在找到了需要解决的问题后，再想办法解决该问题。而不是在设计过程中边想边解决，需要先将所有可能的问题都考虑到，再依次解决。在整个系统设计完成后，如果再遇到新的问题，可以对系统进行适当的更新。
调试时经常会遇到这样那样的错误，有的时候是因为一些最基本的错误，如标点的中英错误，括号的匹配问题，数据的输入错误等。当然，也有很多地方是因为用错了解决方法。在设计的过程中，最能体现出的缺点就是基础不扎实，本可以避免的错误却一再出现。
在实现舞池配对问题过程中，需要使学生循环配对，此程序设计的是当一个光盘的音乐播放结束时，整个配对过程随之结束，而没有让学生再次进去坐席，导致不再从新将学生入座，就无法实现配对。设计的是在每首歌开始之前学生进入队列，可以改为当某个学生坐席为空时，随即让学生再次进入队列，可以解决不能重复换歌曲的问题。
刚开始的时候我直接在开发环境下一边看题一边写代码，瞪了半天什么也没写出来，于是我便先开始在纸上画画写写，将事件的整个过程画下来，然后考虑怎么才能运用代码来实现，一边思考一边写一些粗略的代码，最后从上到下执行代码看看是不是符合题目要求。有没有什么漏洞。等这些完成以后，再在开发环境下将代码完善、编译和调试。虽然说代码还有许多要改进的地方，有的功能还不够完善，可毕竟是自己亲自写出来的，对于程序的条理有了一个清晰的了解，对编程也有了更加深刻的认识。
参考文献
[1] 谭浩强.C程序设计(第三版)[M].北京：清华大学出版社，2005.
[2] 严蔚敏,吴伟民.数据结构(C语言版)[M].北京：清华大学出版社，1997.[3] 陆丽娜.软件工程.北京：经济科学出版社，2005.
[4] 姚诗斌.数据库系统基础.计算机工程与应用,1981年第8期
附录系统源代码
#include #include #include #include #include #define MAXQSIZE 20 //循环队列最大存储量 #define STU_SIZE 5 //学生人数 #define SIZE 100
int idCount=1000;//全局变量控制学生id自增 int length;//记录每首歌配对的数量 int index=0;//记录最终配对表的下标 usingnamespace std; //舞池就坐后的学生信息结构体 struct Admin { char name[15]; char paWord[15]; Admin *next; }; Admin *admin; struct FinalStu { char name[15]; char sex[3]; int id; }; FinalStu stu[STU_SIZE]; FinalStu stuSeat[STU_SIZE];//用来存放入座后的学生信息
FinalStu stuTable[STU_SIZE][2];//用来存放没收歌曲的配对情况 //舞池座位 struct StuQueue { FinalStu *base; int front; int rear; }; StuQueue Boys; //男生队列 StuQueue Girls; //女生队列 //初始化学生坐席
void InitQueue(StuQueue &Q)
17 { Q.base=(FinalStu*)malloc(MAXQSIZE*sizeof(FinalStu)); if(Q.base==NULL)
return ; Q.front=Q.rear=0;
} //学生就坐,首次入队，需要获取学生的id void EnQueue(StuQueue &Q,FinalStu stu) { int i=100; if((Q.rear+1)%MAXQSIZE==Q.front)
return ; strcpy(Q.base[Q.rear].name,stu.name); strcpy(Q.base[Q.rear].sex,stu.sex); Q.base[Q.rear].id=idCount++; Q.rear=(Q.rear+1)%MAXQSIZE; } //非首次入队，不需获取学生的id void EnQueue2(StuQueue &Q,FinalStu stu) { strcpy(Q.base[Q.rear].name,stu.name); strcpy(Q.base[Q.rear].sex,stu.sex); Q.base[Q.rear].id=stu.id; Q.rear=(Q.rear+1)%MAXQSIZE; } //从坐席上出来
FinalStu DeQueue(StuQueue &Q) { FinalStu stu; if(Q.rear!=Q.front) {
stu=Q.base[Q.front]; } Q.front=(Q.front+1)%MAXQSIZE; return stu; } //存放音乐信息 struct Music { char M_Name[15]; Music *next; }; //存放音乐链,循环链表
18 struct MusicList { Music *head;
Music *tail; }; MusicList ML; Music *M_p;//初始化指针
void InitMusic(MusicList & MList) { MList.head=MList.tail=(Music *)malloc(sizeof(Music)); MList.head->next=NULL; } //向音乐链表中添加音乐
void InsertMusic(MusicList &MList,char* name) { Music *p=(Music*)malloc(sizeof(Music)); MList.tail->next=p; strcpy(p->M_Name,name); MList.tail=p; MList.tail->next=MList.head; } //临时队列，用于存放从男女生队列中配对成成功的学生信息 struct TempQueue { FinalStu stu; TempQueue * next; };
struct TempQList { TempQueue *front; TempQueue *rear; }; TempQList TempQL; //临时队列，用于存放每次出来的男女生信息 void
InitQList(TempQList &TQL) { TQL.front=TQL.rear=(TempQueue *)malloc(sizeof(TempQueue)); TQL.front->next=NULL; }
void EnTempQueue(TempQList & TQL,FinalStu stu) { TempQueue *p=(TempQueue *)malloc(sizeof(TempQueue)); p->stu=stu;
19 p->next=NULL; TQL.rear->next=p; TQL.rear=p; }
FinalStu DeTempQueue(TempQList &TQL) { FinalStu stu; TempQueue *p; p=TQL.front->next; if(p==TQL.rear) {
stu=p->stu;
TQL.rear=TQL.front; } else {
stu=p->stu;
TQL.front->next=p->next; } free(p); return stu; } //==========配对信息存放=================== struct MatchList { char musicName[20]; FinalStu stu[2]; }; MatchList matchTable[SIZE]; //从键盘读入学生信息 void GetInfKey() { for(int i=0;i
cout
scanf(\"%s\",stu[i].name);
cout
scanf(\"%s\",stu[i].sex); } } //学生入座
void StudentSit() {
20 for(int i=0;i
if(strcmp(stu[i].sex,\"男\")==0)
EnQueue(Boys,stu[i]);
else
EnQueue(Girls,stu[i]); } } //获取就坐后的男女生性别、姓名、编号,stuSeat[] 存放就坐后的学生信息，包括学生编号
void GetStuSeat() { int i=0;
int j=0; i=Boys.front; j=Girls.front;
while(i!=Boys.rear) {
stuSeat[i]=Boys.base[i];
i++; } while(j!=Girls.rear) {
stuSeat[i]=Girls.base[j];
j++;
i++; } } //将就座的学生信息写入文件 int
InFileStuSeat() { FILE *fp_Seat; int res=0; if((fp_Seat=fopen(\"Seat.txt\",\"wt\"))==NULL) {
cout
return -1; } fprintf(fp_Seat,\"姓名\\t性别\\t序号\\n\"); for(int i=0;i
fprintf(fp_Seat,\"%s\\t%s\\t%d\",stuSeat[i].name,stuSeat[i].sex,stuSeat[i].id);
21
fprintf(fp_Seat,\"\\n\");
res++; } fclose(fp_Seat); return res; }
void PrintStuSeat() { cout
cout
coutnext=NULL; Admin *q=admin; FILE *fp_Admin; if((fp_Admin=fopen(\"admin.txt\",\"rt\"))==NULL) {
cout
return; } while(!feof(fp_Admin)) {
Admin *p=(Admin *)malloc(sizeof(Admin));
p->next=NULL;
fscanf(fp_Admin,\"%s%s\",p->name,p->paWord);
q->next=p;
q=p; } fclose(fp_Admin); } //从文件获取学生信息 void ReadStuFile(int res) { FILE *fp; if(res==1) {
22
if((fp=fopen(\"student1.txt\",\"rt\"))==NULL)
{
cout
return;
} } elseif(res==2) {
if((fp=fopen(\"student2.txt\",\"rt\"))==NULL)
{
cout
return;
} } int i=0; while(!feof(fp))
{
fscanf(fp,\"%s%s\",stu[i].name,stu[i].sex);
i++;
if(i>=STU_SIZE)
break;
} fclose(fp); } //加载音乐信息
int
LoadMusic(int cd) { char music[5][20]; //存放从文件中获取的音乐名称
int res=0; FILE *fp_music; if(cd==1) {
if((fp_music=fopen(\"music1.txt\",\"rt\"))==NULL)
{
cout
return -1;
} } elseif(cd==2) {
if((fp_music=fopen(\"music2.txt\",\"rt\"))==NULL)
{
cout
return -1;
23
} } for(int j=0;j
if(fread(music[j],20*sizeof(char),1,fp_music)==1)
res++;
} fclose(fp_music); InitMusic(ML); for(int i=0;i
InsertMusic(ML,music[i]); } return res; } int InFileMatchTable() { FILE *fp_MTable; if((fp_MTable=fopen(\"matchtable.txt\",\"wt\"))==NULL) {
cout
return -1; } fprintf(fp_MTable,\"歌曲名称\\t姓名\\t性别\\t序号\\t姓名\\t性别\\t序号\\n\"); for(int i=0;i
fprintf(fp_MTable,\"%s\\t\\t%s\\t%s\\t%d\\t\",matchTable[i].musicName,matchTable[i].stu[0].name,matchTable[i].stu[0].sex,matchTable[i].stu[0].id);
fprintf(fp_MTable,\"%s\\t%s\\t%d\\n\",matchTable[i].stu[1].name,matchTable[i].stu[1].sex,matchTable[i].stu[1].id); }
fclose(fp_MTable); return 1; } void StudentSitAgain() { FinalStu stu; while(TempQL.front!=TempQL.rear) {
24
stu=DeTempQueue(TempQL);
if(strcmp(stu.sex,\"男\")==0)
EnQueue2(Boys,stu);
else
EnQueue2(Girls,stu); } } //播放歌曲
void PlayMusic() { coutM_Name; } //下一首
void NextMusic() { M_p=M_p->next; if(M_p==ML.head) {
M_p=ML.head->next; } } //学生配对 void Match() { //FinalStu student[STU_SIZE]; intstatic i=0; int j=0; length=0; while(Boys.front!=Boys.rear&&Girls.front!=Girls.rear) {
EnTempQueue(TempQL,DeQueue(Boys)); //从男生队列中出来进入临时队列
EnTempQueue(TempQL,DeQueue(Girls));//从女生队列中出来进入临时队列
length++;//记录每首歌的配对数
} //从临时队列中将信息赋值给表
TempQueue *tem=TempQL.front->next; while(tem) {
strcpy(matchTable[index].musicName,M_p->M_Name);
strcpy(matchTable[index].stu[0].name,tem->stu.name);
strcpy(matchTable[index].stu[0].sex,tem->stu.sex);
matchTable[index].stu[0].id=tem->stu.id;
//----每曲歌的配对情况
strcpy(stuTable[j][0].name,tem->stu.name);
25
strcpy(stuTable[j][0].sex,tem->stu.sex);
stuTable[j][0].id=tem->stu.id;
tem=tem->next;
//------整个播放过程的配对表
strcpy(matchTable[index].stu[1].name,tem->stu.name);
strcpy(matchTable[index].stu[1].sex,tem->stu.sex);
matchTable[index].stu[1].id=tem->stu.id;
//----每首歌配对表
strcpy(stuTable[j][1].name,tem->stu.name);
strcpy(stuTable[j][1].sex,tem->stu.sex);
stuTable[j][1].id=tem->stu.id;
tem=tem->next;
index++;
j++; }
} //显示每首歌配对情况 void PrintEachMatch() { cout
//length为每首歌的配对长度
{
cout
cout
26 { cout
1、学生就坐\"; cout
2、每曲配对\"
3、显示结果\"; cout
4、查询配对\" 5、退出\";
} //配对显示
void PrintMatchTable() { cout
cout
cout
1、按班级获取(推荐)\"
2、手动输入...\">res; switch(res) { case 1:
//从文件读取数据
int res;
cout
cout
cin>>res;
if(res==1)
{
27
ReadStuFile(1);
}
elseif(res==2)
{
ReadStuFile(2);
}
break; case 2:
cout
GetInfKey();
//键盘键入数据
break; default:
cout
break; } } void MusicMenu() { cout>res; if(res==1)
i=LoadMusic(1); else
i=LoadMusic(2); if(i) {
M_p=ML.head->next;//p指向第一首歌
cout
cin>>ch;
InitQList(TempQL); //初始化临时队列
if(ch==\'Y\'||ch==\'y\')
{
system(\"cls\");
PlayMusic();
Match();
PrintEachMatch();
}
cout
cout
cin>>ch;
while(ch==\'n\'||ch==\'N\')
28
{
system(\"cls\");
Next();
cout
cout
cin>>ch;
}
if(ch==\'q\'||ch==\'Q\')
return; }
} void Welcome() { cout
Admin *p=admin->next;
cout
cin>>userName;
cout
cin>>key;
while(p)
{
if(strcmp(p->name,userName)==0)
break;
p=p->next;
}
if(!p)
{
system(\"cls\");
cout
29
continue;
}
if(p)
{
if(strcmp(p->paWord,key)==0)
{
system(\"cls\");
cout
Sleep(500);
system(\"cls\");
cout
Sleep(500);
system(\"cls\");
cout
Sleep(500);
//system(\"cls\");
break;
}
else
{
system(\"cls\");
cout
continue;
}
} } if(i>=3) {
cout
exit(0); } } void ShowMeage() { system(\"cls\"); int res; cout>res; if(res==1) {
cout
PrintStuSeat();
char ch;
30
cout
cin>>ch;
if(ch==\'Y\'||ch==\'y\')
{
if(InFileMatchTable())
{
cout
}
} } elseif(res==2) {
PrintMatchTable();
char ch;
cout
cin>>ch;
if(ch==\'Y\'||ch==\'y\')
{
if(InFileMatchTable())
cout
}
Sleep(3000); }
} void Quit() {
system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使^\");
31 Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使用\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使用^o^\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使用^o^\\n\\n\\t\\t\\t\\t
-----\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使用^o^\\n\\n\\t\\t\\t\\t
-----GoodBye!\"); Sleep(200); system(\"CLS\");
printf(\"\\n\\n\\n\\n\\n\\n\\n\\n\\t\\t\\t
^o^欢迎下次使用^o^\\n\\n\\t\\t\\t\\t
-----GoodBye!\\n\"); } void CheckByName()
//根据姓名查询配对情况 { char boyName[15]; char girlName[15]; cout>boyName; cout>girlName; int count=0; for(int i=0;i
if(strcmp(matchTable[i].stu[0].name,boyName)==0&& strcmp(matchTable[i].stu[1].name,girlName)==0)
{
count++;
} } if(count==0) {
cout
cout
cout
for(int j=0;j
32
{
if(strcmp(matchTable[j].stu[0].name,boyName)==0&& strcmp(matchTable[j].stu[1].name,girlName)==0)
{
cout
cout
}
} } } void CheckByMusic() { char MusicName[15]; cout>MusicName; int count=0; for(int i=0;i
if(strcmp(matchTable[i].musicName,MusicName)==0)
{
count++;
} } if(count==0) {
cout
} else {
cout
cout
for(int j=0;j
{
if(strcmp(matchTable[j].musicName,MusicName)==0)
{
cout
33 cout
}
} } } //主界面选项
void MainChoose() {
int ins; LoadAdmin(); while(1) {
system(\"cls\");
MainMenu();
cout
cin>>ins;
switch(ins)
{
case 1:
system(\"cls\");
StudentChose();
InitQueue(Boys);
InitQueue(Girls);
StudentSit();
//学生分别入座
GetStuSeat(); //获取学生座位信息
cout
cout
PrintStuSeat();
char ch;
cout
cin>>ch;
if(ch==\'Y\'||ch==\'y\')
{
if(InFileStuSeat())
cout
}
Sleep(3000);
break;
case 2:
system(\"cls\");
cout
MusicMenu();
34
break;
case 3:
ShowMeage();
break;
case 4:
system(\"cls\");
cout
cout
int i;
cin>>i;
switch(i)
{
case 1:
CheckByName();
break;
case 2:
CheckByMusic();
break;
}
//CheckByMusic();
getch();
break;
case 5:
system(\"color FC\");
Quit();
exit(0);
break;
} } } void main() { MainChoose(); }
35
推荐第8篇：工作计划编制
工作（月度）计划编制
一、为什么要写工作计划
1、计划是促进主动工作的有效手段
工作有两种形式：
（1）消极式的工作（救火（补救）式的工作：问题已经发生再赶快处理）；
（2）积极式的工作（防火式的工作 ：预见问题，提前计划，预防问题出现）写工作计划实际上就是对我们自己工作的不断总结、分析，让自己做到清清楚楚、明明白白。计划是促进主动工作的有效手段，是我们走向积极式工作的起点。
2、计划是各级领导和一个单位管理水平的体现
通过工作计划可以变被动等事做变为自动主动做事，因为计划明确了具休事项及相关执行人员、时限，有了工作计划，我们可以改变等主管或领导的吩咐再去做事的习惯，只是在某些需要决策的事情上请示主管或领导就可以了。通过计划对整体工作的统筹安排，个人的工作效率会大大提高。通过加大督促和考核，单位的管理水平会不断提高。
二、工作计划的主要内容
1、年度工作目标的月度分解内容；
2、上级指示及领导交办的专门事项；
3、上月未完成的工作计划内容；
4、日常管理内容；
5、阶段性工作；
5、检查中发现问题的整改；
三、工作计划编制
工作计划的编制是为了更好地实施。计划的内容重于形式。计划内容要实在、简单、清楚、可操作强。
工作计划主要包括(1)工作内容（有的要说明工作方法）、(2)工作分工（执行人）、(3)工作时限。
要真正编制好工作计划，首先要对本部门的工作进行分析，对照本部门工作职责、上级机关的有关管理制度、单位主要工作安排情况等，列出本部门的主要工作、日常性工作以及工作的量化指标，初步形成年度计划，按年度计划内容，结合（
二、工作计划的主要内容）中的内容要求，编制成部门的月度计划。
工作计划并不是工作细目，不能将所有的工作都写进计划。
四、工作计划的执行
各部门每月的工作计划应该拿到例会上进行公开讨论，这既是讨论的过程，民主化管理的过程，也是增强部门凝聚力、提高执行力的过程。因为通过讨论，让部门人员对计划认可，同时让他们认知，明白计划内容，让他们对自己份内的工作清楚，便于他们进行工作准备，有利于提高执行力。
执行要避免“我的方案已经拿出来了，执行是执行人员的事情。出了问题也是执行人员自身的水平问题”的认识。部门负责人要经常跟踪检查执行情况和进度。发现问题时，及时解决；每个部门的工作难免会涉及到其他部门，部门负责人要做好沟通协会调工作；还有，在工作计划的执行过程中，部门负责人既是管理人员，同时还是一个执行人员，要做好方向和原则的管理同时要深入问题和现场。
推荐第9篇：质量计划编制
施工项目质量计划编制的依据和要求
1.什么是项目质量计划？由谁编写？有何作用？
项目质量计划应由项目经理组织编写，需报企业相关管理部门批准后实施;质量计划应体现从工序、分项工程、分部工程到单位工程的过程控制，且应体现从资源投入到完成工程质量最终检验和试验的全过程管理与控制要求。
工程质量计划编制和成功实施是项目质量管理中重要一环，是施工企业质量方针和质量目标的分解和具体表现，又是工程项目质量管理的纲领性文件，也体现出企业质量管理水平.2．质量计划的编制依据有哪些 ？ （1）工程承包合同、设计文件；
（2）施工企业的《质量手册》及相应的程序文件； （3）施工操作规程及作业指导书； （4）各专业工程施工质量验收规范；
（5）《建筑法》、《建设工程质量管理条例》、环境保护条例及法规； （6）安全施工管理条例等。 3.项目质量计划的主要内容有哪些？ (1)编制依据;
(2)项目概况; (3)质量目标; (4)项目质量管理体系; (5)项目资源管理; (6)产品实现; (7)测量、分析和改进; (8)文件和记录的控制; (9)创优措施; (10)项目质量计划的管理。 4．施工项目质量计划的编制要求
施工项目质量计划应由项目经理主持编制。质量计划作为对外质量保证和对内质量控制的依据文件，应体现施工项目从分项工程、分部工程到单位工程的过程控制，同时也要体现从资源投人到完成工程质量最终检验和试验的全过程控制。施工项目质量计划编制的要求主要包括以下几个方面。
（1）质量目标
合同范围内的全部工程的所有使用功能符合设计（或更改）图纸要求。分项、分部、单位工程质量达到既定的施工质量验收统一标准，合格率100%，其中专项达到：①所有隐蔽工程为业主质检部门验收合格。②卫生间不渗漏、地下室、地面不出现渗漏，所有门窗不渗漏雨水。③所有保温层、隔热层不出现冷热桥。④所有高级装饰达到有关设计规定。⑤所有的设备安装、调试符合有关验收规范。⑥特殊工程的目标。⑦工程交工后维修期为一年，其中屋面防水维修期三年。⑧工程基础和地下室 年 月 日前完工； 主体 年 月 日完工；
设备安装和装修 年 月 日交付业主（或安装）； 分包工程××项 年 月 日交工。 （2）管理职责
项目经理是本工程实施的最高负责人，对工程符合设计、验收规范、标准要求负责；对各阶段、各工号按期交工负责。
项目经理委托项目质量副经理（或技术负责人）负责本工程质量计划和质量文件的实施及日常质量管理工作；当有更改时，负责更改后的质量文件活动的控制和管理。
①对本工程的准备、施工、安装、交付和维修整个过程质量活动的控制、管理、监督、改进负责；
②对进场材料、机械设备的合格性负责； ③对分包工程质量的管理、监督、检查负责；
④对设计和合同有特殊要求的工程和部位负责组织有关人员、分包商和用户按规定实施，指定专人进行相互联络，解决相互间接口发生的问题；
⑤对施工图纸、技术资料、项目质量文件、记录的控制和管理负责。
项目生产副经理对工程进度负责，调配人力、物力保证按图纸和规范施工，协调同业主、分包商的关系，负责审核结果、整改措施和质量纠正措施和实施。
队长、工长、测量员、试验员、计量员在项目质量副经理的直接指导下，负责所管部位和分项施工全过程的质量，使其符合图纸和规范要求，有更改者符合更改要求，有特殊规定者符合特殊要求。
材料员、机械员对进场的材料、构件、机械设备进行质量验收或退货、索赔，有特殊要求的物资、构件、机械设备执行质量副经理的指令。对业主提供的物资和机械设备负责按合同规定进行验收；对分包商提供的物资和机械设备按合同规定进行验收。
（3）资源提供
规定项目经理部管理人员及操作工人的岗位任职标准及考核认定方法。
规定项目人员流动时进出人员的管理程序。
规定人员进场培训（包括供方队伍、临时工、新进场人员）的内容、考核、记录等。
规定对新技术、新结构、新材料、新设备修订的操作方法和操作人员进行培训并记录等。
规定施工所需的临时设施（含临建、办公设备、住宿房屋等）、支持性服务手段、施工设备及通讯设备等。
（4）工程项目实现过程策划
规定施工组织设计或专项项目质量的编制要点及接口关系。 规定重要施工过程的技术交底和质量策划要求。
规定新技术、新材料、新结构、新设备的策划要求。 规定重要过程验收的准则或技艺评定方法。
（5）业主提供的材料、机械设备等产品的过程控制 施工项目上需用的材料、机械设备在许多情况下是由业主提供的。对这种情况要做出如下规定：①业主如何标识、控制其提供产品的质量；②检查、检验、验证业主提供产品满足规定要求的方法；③对不合格的处理办法。
（6）材料、机械、设备、劳务及试验等采购控制 由企业自行采购的工程材料、工程机械设备、施工机械设备、工具等，质量计划作如下规定：①对供方产品标准及质量管理体系的要求；②选择、评估、评价和控制供方的方法；③必要时对供方质量计划的要求及引用的质量计划；④采购的法规要求；⑤有可追溯性（追溯所考虑对象的历史、应用情况或所处场所的能力）要求时，要明确追溯内容的形成，记录、标志的主要方法。⑥需要的特殊质量保证证据。
（7）产品标识和可追溯性控制 隐蔽工程、分项分部工程质量验评、特殊要求的工程等必须做可追溯性记录，质量计划要对其可追溯性范围、程序、标识、所需记录及如何控制和分发这些记录等内容做出规定。 坐标控制点、标高控制点、编号、沉降观察点、安全标志、标牌等是工程重要标识记录，质量计划要对这些标识的准确性控制措施、记录等内容做规定。
重要材料（水泥、钢材、构件等）及重要施工设备的运作必须具有可追溯性。 （8）施工工艺过程的控制 对工程从合同签订到交付全过程的控制方法做出规定。
对工程的总进度计划、分段进度计划、分包工程的进度计划、特殊部位进度计划、中间交付的进度计划等做出过程识别和管理规定。
规定工程实施全过程各阶段的控制方案、措施、方法及特别要求等。主要包括下列过程：①施工准备；②土石方工程施工；③基础和地下室施工；④主体工程施工；⑤设备安装；⑥装饰装修；⑦附属建筑施工；⑧分包工程施工；⑨冬、雨期施工；⑩特殊工程施工；⑾交付。 规定工程实施过程需用的程序文件、作业指导书（如工艺标准、操作规程、工法等），作为方案和措施必须遵循的办法。 规定对隐蔽工程、特殊工程进行控制、检查、鉴定验收、中间交付的方法。 规定工程实施过程需要使用的主要施工机械、设备、工具的技术和工作条件，运行方案，操作人员上岗条件和资格等内容，作为对施工机械设备的控制方式。 规定对各分包单位项目上的工作表现及其工作质量进行评估的方法、评估结果送交有关部门、对分包单位的管理办法等，以此控制分包单位。
（9）搬运、贮存、包装、成品保护和交付过程的控制。 规定工程实施过程在形成的分项、分部、单位工程的半成品、成品保护方案、措施、交接方式等内容，作为保护半成品、成品的准则。 规定工程期间交付、竣工交付、工程的收尾、维护、验评、后续工作处理的方案、措施，作为管理的控制方式。
规定重要材料及工程设备的包装防护的方案及方法。 （10）安装和调试的过程控制
对于工程水、电、暖、电讯、通风、机械设备等的安装、检测、调试、验评、交付、不合格的处置等内容规定方案、措施、方式。由于这些工作同土建施工交叉配合较多，因此对于交叉接口程序、验证哪些特性、交接验收、检测、试验设备要求、特殊要求等内容要做明确规定，以便各方面实施时遵循。
（11）检验、试验和测量的过程控制 规定材料、构件、施工条件、结构形式在什么条件、什么时间必须进行检验、试验、复验、以验证是否符合质量和设计要求，如钢材进场必须进行型号、钢种、炉号、批量等内容的检验，不清楚时要进行取样试验或复验。
规定施工现场必须设立试验室（室、员）配置相应的试验设备，完善试验条件，规定试验人员资格和试验内容；对于特定要求要规定试验程序及对程序过程进行控制的措施。 当企业和现场条件不能满足所需各项试验要求时，要规定委托上级试验或外单位试验的方案和措施。当有合同要求的专业试验时，应规定有关的试验方案和措施。
对于需要进行状态检验和试验的内容，必须规定每个检验试验点所需检验、试验的特性、所采用程序、验收准则、必须的专用工具、技术人员资格、标识方式、记录等要求。例如结构的荷载试验等。
当有业主亲自参加见证或试验的过程或部位时，要规定该过程或部位的所在地，见证或试验时间，如何按规定进行检验试验，前后接口部位的要求等内容。例如屋面、卫生间的渗漏试验。
当有当地政府部门要求进行或亲临的试验、检验过程或部位时，要规定该过程或部位在何处、何时、如何按规定由第三方进行检验和试验。例如搅拌站空气粉尘含量测定、防火设施验收、压力容器使用验收，污水排放标准测定等。
对于施工安全设施、用电设施、施工机械设备安装、使用、拆卸等，要规定专门安全技术方案、措施、使用的检查验收标准等内容。 要编制现场计量网络图、明确工艺计量、检测计量、经营计量的网络、计量器具的配备方案、检测数据的控制管理和计量人员的资格。 编制控制测量、施工测量的方案，制定测量仪器配置，人员资格、测量记录控制、标识确认、纠正、管理等措施。
要编制分项、分部、单位工程和项目检查验收、交付验评的方案，作为交验时进行控制的依据。
（12）检验、试验、测量设备的过程控制
规定要在本工程项目上使用所有检验、试验、测量和计量设备的控制和管理制度，包括：①设备的标识方法；②设备校准的方法；③标明、记录设备准状态的方法；④明确哪些记录需要保存，以便一旦发现设备失准时，便确定以前的测试结果是否有效。 （13）不合格品的控制 要编制工种、分项、分部工程不合格产品出现的方案、措施，以及防止与合格之间发生混淆的标识和隔离措施。规定哪些范围不允许出现不合格；明确一旦出现不合格哪些允许修补返工，哪些必须推倒重来，哪些必须局部更改设计或降级处理。 编制控制质量事故发生的措施及一旦发生后的处置措施。
规定当分项分部和单位工程不符合设计图纸（更改）和规范要求时，项目和企业各方面对这种情况的处理有如下职权：①质量监督检查部门有权提出返工修补处理、降级处理或作不合格品处理；②质量监督检查部门以图纸（更改）、技术资料、检测记录为依据用书面形式向以下各方发出通知：当分项分部项目工程不合格时通知项目质量副经理和生产副经理；当分项工程不合格时通知项目经理；当单位工程不合格时通知项目经理和公司生产经理。 上述接收返工修补处理、降级处理或不合格处理通知方有权接受和拒绝这些要求：当通知方和接收通知方意见不能调解时，则上级质量监督检查部门、公司质量主管负责人，乃至经理裁决；若仍不能解决时申请由当地政府质量监督部门裁决。
推荐第10篇：施工进度计划编制
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）后勤服务人员要作好生活服务供应工作，重点抓好吃、住两大难题，食堂的饭菜要保证干净卫生且品种多、价格优，同时开饭时间要随时根据施工进度进行调整，晚上加班应备有夜餐。夏季温度较高的施工时段，安排有效的防暑、降温措施；冬季施工阶段，统一安装采暖空调，确保宿舍及办公环境的温暖舒适。
第11篇：物资计划编制
物资计划编制
一．编制物资计划的基本原则：
1、服从企业方针目标，服从企业整体利益。
2、坚持实事求是原则，强调计划的严肃性，统筹兼顾，合理安排。
3、深入生产现场和当地市场进行考察和调研，直接收集资料，切忌盲目估算。
4、应充分挖潜，并全面考虑企业的经济效益和计划的可行性。二.物资计划的主要内容：计划编制说明、物资编号、名称、规格型号、计量单位、期初库存量、本期需用量、预计储备量、本期计划申请量、物资的技术标准或设计质量要求、时间及到站要求等。 三.物资计划编制依据：
1、工程技术部门按期编制并下达“工程主要物资需要量计算表”
2、劳资、安质部门提供劳保材料需用量；
3、机械部门提供油料、机修材料需用量；
4、各工班提供上述材料以外的其它各种材料需用量。四.物资计划的补充情况包括：
1.若遇施工任务调整或变更设计需调整物资计划时，申请单位应按原渠道，及时提出书面追加、削减计划。
2.工程坍方、防洪抢险等急用物资，供方可根据需方的电报、传真及电话要求及时供应，但应在期末及时做出补充计划，经有关领导
审批后报采供部门。 五．物资计划编制流程：
六．物资计划审批：
1.《辅助材料和工具劳保用品计划》由工区提报，工区设备物资负责人签认（核对库存），工区项经理审批后，由工区项目设物部编制物资采购计划报项目设备物资部，由设物部长签认，分管领导审核，报项目经理审批后方可采购。一般材料如因项目经理外出不能
及时审批的可经分管领导审核后通知采供站及时采购，并及时补办签字手续。协作队伍所需材料必须注明。辅料计划每星期做一次，每月辅料计划不能超过四次。每周的提报时间为星期五下午6点前。在此期间如因计划不周发生计划外要料，每发生一次罚款工区主任200元（如发生安全隐患时，可先采供，后须做补充计划报设物部）。物资进场时间以审批后2天为限。如有个别难以购置的物资需及时向工区领导及项目主管领导汇报。
2.月度主材计划必须由工程部提报，每月28日之前必须将下月《主材需用量计算表》提报给设物部，该表需由制表人、工程部负责人、总工签字。主材计划原则上每月提报一次，提报人应认真，仔细，严谨拟定。如因特殊情况，可做一次补充计划，但必需说明遗漏，或补充原由。 七.物资计划监督：
针对我项目实际情况由分管领导定期监督检查本项目物资计划的执行情况。对由于计划不周造成工程延误、物资积压和浪费等现象应提出批评，情节严重的应追究相关人员的责任。
物资计划编制习题
姓名: 得分: 一.填空
1 编制物资计划的基本原则：（ ） 服从企业整体利益。（ ），强调计划的严肃性，统筹兼顾，合理安排。 2.物资计划审批：各工区项目所报需用量计划，由（ ）签认，（ ）审批后，再报（ ）。由设物部长签认，分管领导审核，报项目经理审批。
3.物资计划的补充情况包括：若遇施工任务调整或变更设计需调整物资计划时，申请单位应按原渠道，及时提出（ ）削减计划。 二．判断题
1.若遇施工任务调整或变更设计需调整物资计划时，申请单位应按原渠道，无需提出书面追加、削减计划。（ ） 2.工程坍方、防洪抢险等急用物资，供方可根据需方的电报、传真及电话要求及时供应，但应在期末及时做出补充计划，经有关领导审批后报采供部门。 （ ） 3.工程技术部门按期编制并下达“工程主要物资需要量计算表”
（ ）
4.编制物资计划的基本原则：服从企业方针目标，服从自身发展利益。（ ）
5项目经理部下达计划期内施工生产任务量。（ ）
三.选择题
1.编制物资计划的基本原则：服从企业方针目标，服从企业整体利益。坚持实事求是原则，强调计划的严肃性，统筹兼顾，合理安排。（ ），直接收集资料，切忌盲目估算。
A.无需深入生产现场和当地市场进行考察和调研 B.询问他人获得二手资料 C.根据自己工作经验
D.深入生产现场和当地市场进行考察和调研
2.物资计划编制依据：工程技术部门按期编制并下达“工程主要物资需要量计算表”;劳资、安质部门提供劳保材料需用量( )各工班提供上述材料以外的其它各种材料需用量。 A.工区提供油料、机修材料需用量; B.工班长提供油料、机修材料需用量; C．工区项目经理提供油料、机修材料需用量; D.机械部门提供油料、机修材料需用量;
答案：填空--- 1...服从企业方针目标 ；坚持实事求是原则 2.设备物资负责人；工区项经理；项目设备物资部 3.书面追加
判断—1.× 2.√3.√4.×5.√
选择---1.D 2.D
第12篇：数据结构课程设计地图着色问题
课程设计报告
课程设计题目：地图着色问题
专业：xxxxxxxxx 班级：xxxxxxxxx 姓名：xxxxxxxxx
一：需求分析：
1) 已知中国地图，对各省进行着色，要求相邻省所使用的颜色不同，并保证使用的颜色总数最少；
2) 将各省进行编号，然后利用无向图个顶点之间的边来表示各省的相邻关系； 3) 演示程序以用户和计算机的对话方式进行；
4) 最后对结果做出简单分析。
二：概要设计
一：设计思路
把34个省看成34个顶点，从选定的第一个顶点开始着色，先试第一种颜色，如果这个颜色与这个顶点的其他邻接顶点的颜色不重复，则这个顶点就是用这种颜色，程序开始对下一个顶点着色；如果着色重复，则使用下一种颜色重复上面的操作。着色过程就是一个递归的过程，直到所有的顶点都处理完后结束着色。
二：数据结构设计
因为这个程序是对图的操作，所以程序采用的逻辑结构是图状，存储结构选用邻接表，考虑用邻接表是因为一般的地图的某一个顶点并不会与很多的顶点相邻接，如果用邻接矩阵会浪费很多的存储空间，所以我选择的邻接表来存储。
其中：
typedef struct ArcNode { int x;
（表示与当前顶点所表示省份相邻的省份的位置信息）
struct ArcNode *next;
（指向下一个弧结点） }ArcNode;
（表示省份之间相邻关系的弧结点） typedef struct { char *name; （顶点所表示的省份的名称）
int color;
（省份的颜色，用数字表示不同的颜色）
ArcNode *firstnext; （指向第一个弧） }shengfen[35];
三：详细设计
该程序一共包含三个模版：分别为初始化模版、着色模版和输出模版。
1.初始化模块
声明表示省份的顶点信息、省份之间相邻关系的弧的信息，并为其赋值。
2.着色模块
为各个省份着色。 for(i=1;i
sheng[i].color=0; } for(i=1;i
j=1;
p=sheng[i].firstnext;
while(p!=NULL)
{
while(p!=NULL&&j!=sheng[p->x].color)
{
p=p->next;
}
if(p!=NULL)
j++;
}
sheng[i].color=j; } 3.输出模块
输出各个省份的颜色信息。
for(i=1;i
printf(\"%s:\",sheng[i].name);
printf(\"%d\\n\",sheng[i].color); }
printf(\"/n0表示白色,1表示蓝色,2表示红色,3表示绿色,4表示黄色\"); return 0;
四：调试分析
因为我们的程序已知是中国地图，为中国地图染色，所以程序没有输入，只有输出信息。从输出的信息来看，我们最多使用了4种颜色。关于程序测试时存在的问题，我们程序在写完之后，出现了没有错误但是无法输出信息的问题，从网上查找发现是对警告没处理好的原因，随后我们参考了网上的解决方案把问题解决了。关于程序的改进，我们的程序使用的是有向图，但省份之间的相邻关系用无向图就可以表示，这是程序可以改进的地方。其次，我们的程序输出结果描述省份颜色的是数字，也可以改进后使之输出具体的颜色。
五：源程序清单
#include #include typedef struct ArcNode{ int x; struct ArcNode *next; }ArcNode; typedef struct{ char *name; int color; ArcNode *firstnext; }shengfen[35]; int main() { shengfen sheng; int i,j; ArcNode *p,*hu1,*hu2,*hu3,*hu4,*hu5,*hu6,*hu7,*hu8,*hu9,*hu10,*hu11,*hu12,*hu13,*hu14,*hu15,*hu16,*hu17,*hu18; ArcNode *hu19,*hu20,*hu21,*hu22,*hu23,*hu24,*hu25,*hu26,*hu27,*hu28,*hu29,*hu30,*hu31,*hu32,*hu33,*hu34,*hu35; ArcNode *hu36,*hu37,*hu38,*hu39,*hu40,*hu41,*hu42,*hu43,*hu44,*hu45,*hu46,*hu47,*hu48,*hu49,*hu50,*hu51,*hu52; ArcNode *hu53,*hu54,*hu55,*hu56,*hu57,*hu58,*hu59,*hu60,*hu61,*hu62,*hu63,*hu64,*hu65,*hu66; ArcNode *hu67,*hu68,*hu69,*hu70,*hu71,*hu72,*hu73,*hu74,*hu75,*hu76,*hu77,*hu78,*hu79,*hu80,*hu81,*hu82,*hu83,*hu84; ArcNode *hu85,*hu86,*hu87,*hu88,*hu89,*hu90,*hu91,*hu92,*hu93,*hu94,*hu95,*hu96,*hu97,*hu98,*hu99,*hu100; ArcNode *hu101,*hu102,*hu103,*hu104,*hu105,*hu106,*hu107,*hu108,*hu109,*hu110,*hu111,*hu112,*hu113,*hu114,*hu115,*hu116,*hu117; ArcNode *hu118,*hu119,*hu120,*hu121,*hu122,*hu123,*hu124,*hu125,*hu126,*hu127,*hu128,*hu129; ArcNode *hu130,*hu131,*hu132,*hu133,*hu134,*hu135,*hu136,*hu137,*hu138,*hu139,*hu1
40,*hu141,*hu142; hu1=(ArcNode *)malloc(sizeof(ArcNode)); hu2=(ArcNode *)malloc(sizeof(ArcNode)); hu3=(ArcNode *)malloc(sizeof(ArcNode)); hu4=(ArcNode *)malloc(sizeof(ArcNode)); hu5=(ArcNode *)malloc(sizeof(ArcNode)); hu6=(ArcNode *)malloc(sizeof(ArcNode)); hu7=(ArcNode *)malloc(sizeof(ArcNode)); hu8=(ArcNode *)malloc(sizeof(ArcNode)); hu9=(ArcNode *)malloc(sizeof(ArcNode)); hu10=(ArcNode *)malloc(sizeof(ArcNode)); hu11=(ArcNode *)malloc(sizeof(ArcNode)); hu12=(ArcNode *)malloc(sizeof(ArcNode)); hu13=(ArcNode *)malloc(sizeof(ArcNode)); hu14=(ArcNode *)malloc(sizeof(ArcNode)); hu15=(ArcNode *)malloc(sizeof(ArcNode)); hu16=(ArcNode *)malloc(sizeof(ArcNode)); hu17=(ArcNode *)malloc(sizeof(ArcNode)); hu18=(ArcNode *)malloc(sizeof(ArcNode)); hu19=(ArcNode *)malloc(sizeof(ArcNode)); hu20=(ArcNode *)malloc(sizeof(ArcNode)); hu21=(ArcNode *)malloc(sizeof(ArcNode)); hu22=(ArcNode *)malloc(sizeof(ArcNode)); hu23=(ArcNode *)malloc(sizeof(ArcNode)); hu24=(ArcNode *)malloc(sizeof(ArcNode)); hu25=(ArcNode *)malloc(sizeof(ArcNode)); hu26=(ArcNode *)malloc(sizeof(ArcNode)); hu27=(ArcNode *)malloc(sizeof(ArcNode)); hu28=(ArcNode *)malloc(sizeof(ArcNode)); hu29=(ArcNode *)malloc(sizeof(ArcNode)); hu30=(ArcNode *)malloc(sizeof(ArcNode)); hu31=(ArcNode *)malloc(sizeof(ArcNode)); hu32=(ArcNode *)malloc(sizeof(ArcNode)); hu33=(ArcNode *)malloc(sizeof(ArcNode)); hu34=(ArcNode *)malloc(sizeof(ArcNode)); hu35=(ArcNode *)malloc(sizeof(ArcNode)); hu36=(ArcNode *)malloc(sizeof(ArcNode)); hu37=(ArcNode *)malloc(sizeof(ArcNode)); hu38=(ArcNode *)malloc(sizeof(ArcNode)); hu39=(ArcNode *)malloc(sizeof(ArcNode)); hu40=(ArcNode *)malloc(sizeof(ArcNode)); hu41=(ArcNode *)malloc(sizeof(ArcNode)); hu42=(ArcNode *)malloc(sizeof(ArcNode)); hu43=(ArcNode *)malloc(sizeof(ArcNode));
hu44=(ArcNode *)malloc(sizeof(ArcNode)); hu45=(ArcNode *)malloc(sizeof(ArcNode)); hu46=(ArcNode *)malloc(sizeof(ArcNode)); hu47=(ArcNode *)malloc(sizeof(ArcNode)); hu48=(ArcNode *)malloc(sizeof(ArcNode)); hu49=(ArcNode *)malloc(sizeof(ArcNode)); hu50=(ArcNode *)malloc(sizeof(ArcNode)); hu51=(ArcNode *)malloc(sizeof(ArcNode)); hu52=(ArcNode *)malloc(sizeof(ArcNode)); hu53=(ArcNode *)malloc(sizeof(ArcNode)); hu54=(ArcNode *)malloc(sizeof(ArcNode)); hu55=(ArcNode *)malloc(sizeof(ArcNode)); hu56=(ArcNode *)malloc(sizeof(ArcNode)); hu57=(ArcNode *)malloc(sizeof(ArcNode)); hu58=(ArcNode *)malloc(sizeof(ArcNode)); hu59=(ArcNode *)malloc(sizeof(ArcNode)); hu60=(ArcNode *)malloc(sizeof(ArcNode)); hu61=(ArcNode *)malloc(sizeof(ArcNode)); hu62=(ArcNode *)malloc(sizeof(ArcNode)); hu63=(ArcNode *)malloc(sizeof(ArcNode)); hu64=(ArcNode *)malloc(sizeof(ArcNode)); hu65=(ArcNode *)malloc(sizeof(ArcNode)); hu66=(ArcNode *)malloc(sizeof(ArcNode)); hu67=(ArcNode *)malloc(sizeof(ArcNode)); hu68=(ArcNode *)malloc(sizeof(ArcNode)); hu69=(ArcNode *)malloc(sizeof(ArcNode)); hu70=(ArcNode *)malloc(sizeof(ArcNode)); hu71=(ArcNode *)malloc(sizeof(ArcNode)); hu72=(ArcNode *)malloc(sizeof(ArcNode)); hu73=(ArcNode *)malloc(sizeof(ArcNode)); hu74=(ArcNode *)malloc(sizeof(ArcNode)); hu75=(ArcNode *)malloc(sizeof(ArcNode)); hu76=(ArcNode *)malloc(sizeof(ArcNode)); hu77=(ArcNode *)malloc(sizeof(ArcNode)); hu78=(ArcNode *)malloc(sizeof(ArcNode)); hu79=(ArcNode *)malloc(sizeof(ArcNode)); hu80=(ArcNode *)malloc(sizeof(ArcNode)); hu81=(ArcNode *)malloc(sizeof(ArcNode)); hu82=(ArcNode *)malloc(sizeof(ArcNode)); hu83=(ArcNode *)malloc(sizeof(ArcNode)); hu84=(ArcNode *)malloc(sizeof(ArcNode)); hu85=(ArcNode *)malloc(sizeof(ArcNode)); hu86=(ArcNode *)malloc(sizeof(ArcNode)); hu87=(ArcNode *)malloc(sizeof(ArcNode));
hu88=(ArcNode *)malloc(sizeof(ArcNode)); hu89=(ArcNode *)malloc(sizeof(ArcNode)); hu90=(ArcNode *)malloc(sizeof(ArcNode)); hu91=(ArcNode *)malloc(sizeof(ArcNode)); hu92=(ArcNode *)malloc(sizeof(ArcNode)); hu93=(ArcNode *)malloc(sizeof(ArcNode)); hu94=(ArcNode *)malloc(sizeof(ArcNode)); hu95=(ArcNode *)malloc(sizeof(ArcNode)); hu96=(ArcNode *)malloc(sizeof(ArcNode)); hu97=(ArcNode *)malloc(sizeof(ArcNode)); hu98=(ArcNode *)malloc(sizeof(ArcNode)); hu99=(ArcNode *)malloc(sizeof(ArcNode)); hu100=(ArcNode *)malloc(sizeof(ArcNode)); hu101=(ArcNode *)malloc(sizeof(ArcNode)); hu102=(ArcNode *)malloc(sizeof(ArcNode)); hu103=(ArcNode *)malloc(sizeof(ArcNode)); hu104=(ArcNode *)malloc(sizeof(ArcNode)); hu105=(ArcNode *)malloc(sizeof(ArcNode)); hu106=(ArcNode *)malloc(sizeof(ArcNode)); hu107=(ArcNode *)malloc(sizeof(ArcNode)); hu108=(ArcNode *)malloc(sizeof(ArcNode)); hu109=(ArcNode *)malloc(sizeof(ArcNode)); hu110=(ArcNode *)malloc(sizeof(ArcNode)); hu111=(ArcNode *)malloc(sizeof(ArcNode)); hu112=(ArcNode *)malloc(sizeof(ArcNode)); hu113=(ArcNode *)malloc(sizeof(ArcNode)); hu114=(ArcNode *)malloc(sizeof(ArcNode)); hu115=(ArcNode *)malloc(sizeof(ArcNode)); hu116=(ArcNode *)malloc(sizeof(ArcNode)); hu117=(ArcNode *)malloc(sizeof(ArcNode)); hu118=(ArcNode *)malloc(sizeof(ArcNode)); hu119=(ArcNode *)malloc(sizeof(ArcNode)); hu120=(ArcNode *)malloc(sizeof(ArcNode)); hu121=(ArcNode *)malloc(sizeof(ArcNode)); hu122=(ArcNode *)malloc(sizeof(ArcNode)); hu123=(ArcNode *)malloc(sizeof(ArcNode)); hu124=(ArcNode *)malloc(sizeof(ArcNode)); hu125=(ArcNode *)malloc(sizeof(ArcNode)); hu126=(ArcNode *)malloc(sizeof(ArcNode)); hu127=(ArcNode *)malloc(sizeof(ArcNode)); hu128=(ArcNode *)malloc(sizeof(ArcNode)); hu129=(ArcNode *)malloc(sizeof(ArcNode)); hu130=(ArcNode *)malloc(sizeof(ArcNode)); hu131=(ArcNode *)malloc(sizeof(ArcNode));
hu132=(ArcNode *)malloc(sizeof(ArcNode)); hu133=(ArcNode *)malloc(sizeof(ArcNode)); hu134=(ArcNode *)malloc(sizeof(ArcNode)); hu135=(ArcNode *)malloc(sizeof(ArcNode)); hu136=(ArcNode *)malloc(sizeof(ArcNode)); hu137=(ArcNode *)malloc(sizeof(ArcNode)); hu138=(ArcNode *)malloc(sizeof(ArcNode)); hu139=(ArcNode *)malloc(sizeof(ArcNode)); hu140=(ArcNode *)malloc(sizeof(ArcNode)); hu141=(ArcNode *)malloc(sizeof(ArcNode)); hu142=(ArcNode *)malloc(sizeof(ArcNode)); sheng[1].name=\"heilongjiang\"; hu1->x=2; hu2->x=4; sheng[1].firstnext=hu1; hu1->next=hu2; hu2->next=NULL; sheng[2].name=\"jilin\"; hu3->x=4; hu4->x=3; hu141->x=1; sheng[2].firstnext=hu3; hu3->next=hu4; hu4->next=hu141; hu141->next=NULL; sheng[3].name=\"liaoning\"; hu5->x=4; hu6->x=10; hu142->x=2; sheng[3].firstnext=hu5; hu5->next=hu6; hu6->next=hu142; hu142->next=NULL; sheng[4].name=\"neimenggu\"; hu7->x=1; hu8->x=2; hu9->x=3; hu10->x=10; hu11->x=9; hu12->x=8; hu13->x=7; hu14->x=6; hu15->x=5; sheng[4].firstnext=hu7;
hu7->next=hu8; hu8->next=hu9; hu9->next=hu10; hu10->next=hu11; hu11->next=hu12; hu12->next=hu13; hu13->next=hu14; hu14->next=hu15; hu15->next=NULL; sheng[5].name=\"xinjiang\"; hu16->x=6; hu17->x=13; hu18->x=16; sheng[5].firstnext=hu16; hu16->next=hu17; hu17->next=hu18; hu18->next=NULL; sheng[6].name=\"gansu\"; hu19->x=4; hu20->x=7; hu21->x=8; hu22->x=17; hu23->x=13; hu24->x=5; sheng[6].firstnext=hu19; hu19->next=hu20; hu20->next=hu21; hu21->next=hu22; hu22->next=hu23; hu23->next=hu24; hu24->next=NULL; sheng[7].name=\"ningxia\"; hu25->x=4; hu26->x=8; hu27->x=6; sheng[7].firstnext=hu25; hu25->next=hu26; hu26->next=hu27; hu27->next=NULL; sheng[8].name=\"shanxi1\"; hu28->x=4; hu29->x=9; hu30->x=14; hu31->x=19;
hu32->x=18; hu33->x=17; hu34->x=6; hu35->x=7; sheng[8].firstnext=hu28; hu28->next=hu29; hu29->next=hu30; hu30->next=hu31; hu31->next=hu32; hu32->next=hu33; hu33->next=hu34; hu34->next=hu35; hu35->next=NULL; sheng[9].name=\"shanxi2\"; hu36->x=4; hu37->x=10; hu38->x=14; hu39->x=8; sheng[9].firstnext=hu36; hu36->next=hu37; hu37->next=hu38; hu38->next=hu39; hu39->next=NULL; sheng[10].name=\"hebei\"; hu40->x=4; hu41->x=3; hu42->x=11; hu43->x=12; hu44->x=15; hu45->x=14; hu46->x=9; sheng[10].firstnext=hu40; hu40->next=hu41; hu41->next=hu42; hu42->next=hu43; hu43->next=hu44; hu44->next=hu45; hu45->next=hu46; hu46->next=NULL; sheng[11].name=\"beijing\"; hu47->x=10; sheng[11].firstnext=hu47; hu47->next=NULL; sheng[12].name=\"tianjin\";
hu48->x=10; sheng[12].firstnext=hu48; hu48->next=NULL; sheng[13].name=\"qinghai\"; hu49->x=5; hu50->x=6; hu51->x=17; hu52->x=16; sheng[13].firstnext=hu49; hu49->next=hu50; hu50->next=hu51; hu51->next=hu52; hu52->next=NULL; sheng[14].name=\"henan\"; hu53->x=9; hu54->x=10; hu55->x=15; hu56->x=21; hu57->x=20; hu58->x=19; hu59->x=8; sheng[14].firstnext=hu53; hu53->next=hu54; hu54->next=hu55; hu55->next=hu56; hu56->next=hu57; hu57->next=hu58; hu58->next=hu59; hu59->next=NULL; sheng[15].name=\"shandong\"; hu60->x=10; hu61->x=14; hu62->x=21; sheng[15].firstnext=hu60; hu60->next=hu61; hu61->next=hu62; hu62->next=NULL; sheng[16].name=\"xizang\"; hu63->x=5; hu64->x=13; hu65->x=17; hu66->x=23; sheng[16].firstnext=hu63; hu63->next=hu64;
hu64->next=hu65; hu65->next=hu66; hu66->next=NULL; sheng[17].name=\"sichuan\"; hu67->x=13; hu68->x=6; hu69->x=8; hu70->x=18; hu71->x=24; hu72->x=23; hu73->x=16; sheng[17].firstnext=hu67; hu67->next=hu68; hu68->next=hu69; hu69->next=hu70; hu70->next=hu71; hu71->next=hu72; hu72->next=hu73; hu73->next=NULL; sheng[18].name=\"chongqing\"; hu74->x=17; hu75->x=8; hu76->x=19; hu77->x=25; hu78->x=24; sheng[18].firstnext=hu74; hu74->next=hu75; hu75->next=hu76; hu76->next=hu77; hu77->next=hu78; hu78->next=NULL; sheng[19].name=\"hubei\"; hu79->x=8; hu80->x=14; hu81->x=20; hu82->x=26; hu83->x=25; hu84->x=18; sheng[19].firstnext=hu79; hu79->next=hu80; hu80->next=hu81; hu81->next=hu82; hu82->next=hu83; hu83->next=hu84;
hu84->next=NULL; sheng[20].name=\"anhui\"; hu85->x=14; hu86->x=21; hu87->x=27; hu88->x=26; hu89->x=19; sheng[20].firstnext=hu85; hu85->next=hu86; hu86->next=hu87; hu87->next=hu88; hu88->next=hu89; hu89->next=NULL; sheng[21].name=\"jiangsu\"; hu90->x=15; hu91->x=14; hu92->x=20; hu93->x=27; hu94->x=22; sheng[21].firstnext=hu90; hu90->next=hu91; hu91->next=hu92; hu92->next=hu93; hu93->next=hu94; hu94->next=NULL; sheng[22].name=\"shanghai\"; hu95->x=21; hu96->x=27; sheng[22].firstnext=hu95; hu95->next=hu96; hu96->next=NULL; sheng[23].name=\"yunnan\"; hu97->x=16; hu98->x=17; hu99->x=24; hu100->x=29; sheng[23].firstnext=hu97; hu97->next=hu98; hu98->next=hu99; hu99->next=hu100; hu100->next=NULL; sheng[24].name=\"guizhou\"; hu101->x=17; hu102->x=24;
hu103->x=29; hu104->x=23; hu105->x=18; sheng[24].firstnext=hu101; hu101->next=hu102; hu102->next=hu103; hu103->next=hu104; hu104->next=hu105; hu105->next=NULL; sheng[25].name=\"hunan\"; hu106->x=18; hu107->x=19; hu108->x=26; hu109->x=30; hu110->x=29; hu111->x=24; sheng[25].firstnext=hu106; hu106->next=hu107; hu107->next=hu108; hu108->next=hu109; hu109->next=hu110; hu110->next=hu111; hu111->next=NULL; sheng[26].name=\"jiangxi\"; hu112->x=25; hu113->x=19; hu114->x=20; hu115->x=27; hu116->x=28; hu117->x=30; sheng[26].firstnext=hu112; hu112->next=hu113; hu113->next=hu114; hu114->next=hu115; hu115->next=hu116; hu116->next=hu117; hu117->next=NULL; sheng[27].name=\"zhejiang\"; hu118->x=22; hu119->x=21; hu120->x=20; hu121->x=26; hu122->x=28; sheng[27].firstnext=hu118;
hu118->next=hu119; hu119->next=hu120; hu120->next=hu121; hu121->next=hu122; hu122->next=NULL; sheng[28].name=\"fujian\"; hu123->x=27; hu124->x=26; hu125->x=30; sheng[28].firstnext=hu123; hu123->next=hu124; hu124->next=hu125; hu125->next=NULL; sheng[29].name=\"guangxi\"; hu126->x=23; hu127->x=24; hu128->x=25; hu129->x=30; sheng[29].firstnext=hu126; hu126->next=hu127; hu127->next=hu128; hu128->next=hu129; hu129->next=NULL; sheng[30].name=\"guangdong\"; hu130->x=29; hu131->x=25; hu132->x=26; hu133->x=28; hu134->x=31; hu135->x=32; hu136->x=34; sheng[30].firstnext=hu130; hu130->next=hu131; hu131->next=hu132; hu132->next=hu133; hu133->next=hu134; hu134->next=hu135; hu135->next=hu136; hu136->next=NULL; sheng[31].name=\"aomen\"; hu137->x=30; sheng[31].firstnext=hu137; hu137->next=NULL; sheng[32].name=\"xianggang\";
hu138->x=30; sheng[32].firstnext=hu138; hu138->next=NULL; sheng[33].name=\"taiwan\"; hu139->x=28; sheng[33].firstnext=hu139; hu139->next=NULL; sheng[34].name=\"hainan\"; hu140->x=30; sheng[34].firstnext=hu140; hu140->next=NULL; for(i=1;i
sheng[i].color=0; } for(i=1;i
j=1;
p=sheng[i].firstnext;
while(p!=NULL)
{
while(p!=NULL&&j!=sheng[p->x].color)
{
p=p->next;
}
if(p!=NULL)
j++;
}
sheng[i].color=j; } for(i=1;i
printf(\"%s:\",sheng[i].name);
printf(\"%d\\n\",sheng[i].color); }
printf(\"/n0表示白色,1表示蓝色,2表示红色,3表示绿色,4表示黄色\"); return 0; }
第13篇：数据结构课程设计学生搭配问题
数据结构课程设计
报 告
设计题目：
学生搭配问题
专 业： 计算机科学与技术 学生姓名： 班级学号： 分组成员： 指导教师：
学生搭配问题课程设计报告
一、设计时间
二、设计地点
三、设计目的
1.通过这次课程设计进一步熟悉基本概念；2.熟练掌握C语言编程，了解程序基本的流程；
3.运用所学C语言知识，掌握数据结构方法循环队列应用，算法思路设计；4.培养查阅资料，独立思考问题的能力。
四、设计小组成员
五、指导老师
六、设计课题
学生搭配问题
七、基本思路及关键问题的解决方法
基本思路：队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表。
循环队列是在队列的顺序存储结构中，除了用乙组地址连续的存储单元依次存放从队列头到队列尾的元素外，尚需附设两个指针front和rear分别指示队列头元素和队列尾元素的位置。
循环队列（两个），将男生、女生两组人分别存放，以实现循环配对输出。循环队列的入队，出队，判队满，判队空。
（1） 要模拟动态地显示出现题目中所要求的循环，我们要先建立两个循环队列SqQueue和SqQueue2。
（2） 将男生、女生两组人分别存入这两个队列。以实现他们的循环配对输出，这是循环队列固有的特性。
（3） 利用循环队列的特性，将男女生分别进行入队列和出队列操作，且实现搭配输出。
（4） 循环队列的长度分别设为男女生的个数即可。
（5） 在计算机终端输出的结果是：根据要求输出男生女生搭配情况
关键问题: 循环队列的应用
解决方法：数据模型（逻辑结构）: 循环队列（两个），将男生、女生两组人分别存放，以实现循环配对输出。
存储结构: 循环链表
核心算法: 循环队列的入队，出队，判队满，判队空。 输入数据: 男生人数、女生人数，歌曲数量
输出数据: 每一首歌曲播放时，男生和女生搭配情况（只输出编号即可）当要查找的男女搭配时输出歌曲编号，和他们搭配的总次数。通过以上分析，该程序具有可行性。
八、算法及流程图
九、调试过程中出现的问题及解决方法
问题：在构造队列时，设队列分配的最大空间为男女生的个数，此时便无法根据Q.front=Q.rear来判别队列空间是“空”还是“满”,因此，在入队操作即插入一个新元素作为新的队尾元素时出现了问题，即最后一位同学无法入队。
解决方法：将队列分配的最大空间至少再增加一个
十、测试及运行结果
测试输入数据：男女生的个数曲子数和要查找的男女生编号
输出结果为：每首曲子男女生搭配的情况 程序运行界面：
十一、课程设计心得体会
通过一周的学习和实践，解决实际问题（学生搭配问题），让我对循环队列有了更深的了解，对数据结构产生了浓厚的兴趣，同时也让我提高了解决实际问题的能力。
我们要不断的通过上机来提高自己的学习水平，在上机的同时改正了自己对某些算法的错误使用，使自己在通过程序解决问题时抓住关键算法，有了算法设计思想和流程图，并用C语言描绘出关键算法
十二、源程序
#include #include #include #include #define MAXSIZE 60 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef int system; typedef struct QNode{ int num; struct QNode *next; }QNode,* QueuePtr; typedef struct{ QueuePtr front; QueuePtr rear; }LinkQueue; void sleep( clock_t wait ) //延迟函数 { clock_t goal; goal = wait + clock(); while( goal >clock() ) ; } void InitQ(LinkQueue &Q) //建立空队列 { QueuePtr p; p=(QueuePtr)malloc(sizeof(QNode)); Q.front=p; Q.rear=p; Q.front->next=NULL; } void EnQueue(LinkQueue &Q,int num) { QueuePtr p; p=(QueuePtr)malloc(sizeof(QNode)); p->num=num; p->next=NULL; Q.rear->next=p; Q.rear=p; } void DeQueue(LinkQueue &Q, int &num) { QueuePtr p,q; if(Q.front==Q.rear)
printf(\"队列为空\"); p=Q.front->next; num=p->num; Q.front->next=p->next; q=p->next; if(Q.rear==q)
Q.rear=Q.front; free(p); } void printF(LinkQueue &F,int i) //打印第i首曲子时女队的情况 { QueuePtr p; int n=1; while(n
printf(\"_ \");
n++; } p=F.front->next; while(F.rear!=p) {
printf(\"%d \",p->num);
p=p->next;} printf(\"%d \\n\",p->num); } void printM(LinkQueue &M,int i) //打印第i首曲子时男队的情况 { QueuePtr p; int n=1; while(n
printf(\"_ \");
n++; } p=M.front->next; while(M.rear!=p) {
printf(\"%d \",p->num);
p=p->next; } printf(\"%d \\n\",p->num); } void main() { int m,n,k,i,a,b; int count=0,num; QueuePtr p,q; LinkQueue F; //女生队
LinkQueue M; //男生队
printf(\"请输入女生数量：\"); scanf(\"%d\",&m); printf(\"请输入男生数量：\"); scanf(\"%d\",&n); printf(\"请输曲子号：\"); scanf(\"%d\",&k); printf(\"请输入要查找的男生编号：\"); scanf(\"%d\",&a); printf(\"请输入要查找的女生编号：\"); scanf(\"%d\",&b); InitQ(F); InitQ(M); for(i=1;i
EnQueue(F,i); } for(i=1;i
EnQueue(M,i); } for(i=1;i
system(\"CLS\");
printf(\"第%d首曲子 \\n\",i);
printF(F,i);
printM(M,i);
p=F.front->next;
q=M.front->next;
printf(\"目前跳舞的是第%d号女生和第%d号男生\\n\",p->num,q->num);
if(p->num==a&&q->num==b)
{
count++; printf(\"第%d曲是要查找的男女生跳舞\\n\",i);
}
sleep(3000);
DeQueue(F,num); EnQueue(F,num);
DeQueue(M,num);
EnQueue(M,num); } printf(\"该对男女生共跳舞%d次\\n\",count); } 十
三、参考文献
[1] 数据结构（C语言版）严蔚敏 吴伟明 编著，清华大学出版社 [2] C语言程序设计（第三版）谭浩强 著，清华大学出版社
第14篇：数据结构
实验：线性表的基本操作
【实验目的】
学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。对顺序表建立、插入、删除的基本操作，对单链表建立、插入、删除的基本操作算法。
【实验内容】
1.顺序表的实践
1) 建立4个元素的顺序表s=sqlist[]={1，2，3，4，5}，实现顺序表建立的基本操作。
2) 在sqlist []={1，2，3，4，5}的元素4和5之间插入一个元素9，实现顺序表插入的基本操作。
3) 在sqlist []={1，2，3，4，9，5}中删除指定位置（i=5）上的元素9，实现顺序表的删除的基本操作。 2.单链表的实践
3.1) 建立一个包括头结点和4个结点的（5，4，2，1）的单链表，实现单链表建立的基本操作。
2) 将该单链表的所有元素显示出来。
3) 在已建好的单链表中的指定位置（i=3）插入一个结点3，实现单链表插入的基本操作。
4) 在一个包括头结点和5个结点的（5，4，3，2，1）的单链表的指定位置（如i=2）删除一个结点，实现单链表删除的基本操作。 5) 实现单链表的求表长操作。
【实验步骤】
1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。给文件起好名字，选好路径，点OK。至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码
5．编译－＞链接－＞调试
【实验心得】
线性是我们学习数据结构中，碰到的第一个数据结构。学习线性表的重点掌握顺序表和单链表的各种算法和时间性能分析。线性表右两种存储方式即顺序存储结构和链式存储结构。通过学习我知道了对线性表进行建立、插入、删除，同时单链表也是进行建立、插入、删除。而对于顺序表的插入删除运算，其平均时间复杂度均为0（n）.通过这次的学习，掌握的太熟练，主要是课本上的知识点没有彻底的理解，回去我会多看书，理解重要的概念。总之，这次实验我找到了自己的不足之处，以后会努力的。
实验二：栈的表示与实现及栈的应用
【实验目的】
（1） 掌握栈的顺序存储结构及其基本操作的实现。 （2） 掌握栈后进先出的特点，并利用其特性在解决实际问题中的应用。 （3） 掌握用递归算法来解决一些问题。 【实验内容】
1.编写程序，对于输入的任意一个非负十进制整数，输出与其等值的八进制数。
2.编写递归程序，实现N！的求解。3.编写递归程序，实现以下函数的求解。
n,n0,1Fib(n) Fib(n1)Fib(n2),n1
4.编写程序，实现Hanoi塔问题。【实验步骤】 1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。给文件起好名字，选好路径，点OK。至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码
5．编译－＞链接－＞调试
【实验心得】
通过这次的学习我掌握了栈这种抽象数据类型的特点，并能在相应的应用任务中正确选用它；总的来说，栈是操作受限的线性表，是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶（top），相应地，表头端称为栈底（botton）；栈又称为后进先出（Last In First Out）的线性表,简称LIFO结构，因为它的修改是按后进先出的原则进行的。
加上这个实验，我已经学了线性表（顺序表，单链表）和栈，知道它们都是线性表，而且对以后的学习有很大的作用，可以说这是学习以后知识的总要基础。
实验三：二叉树的建立及遍历
【实验目的】
（1） 掌握利用先序序列建立二叉树的二叉链表的过程。 （2） 掌握二叉树的先序、中序和后序遍历算法。 【实验内容】
1.编写程序，实现二叉树的建立，并实现先序、中序和后序遍历。如：输入先序序列abc###de###，则建立如下图所示的二叉树。
并显示其先序序列为：abcde 中序序列为：cbaed 后序序列为：cbeda 【实验步骤】 1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。给文件起好名字，选好路径，点OK。至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码
5．编译－＞链接－＞调试
【实验心得】
这次试验是关于二叉树的常见操作，主要是二叉树的建立和遍历，在这次实验中我按先序方式建立二叉树的，而遍历方式则相对要多一些，有递归的先序、中序、后序遍历，和非递归的先序、中序、后序遍历，此外还有层次遍历.二叉树高度和叶子个数的计算和遍历相差不大，只是加些判断条件，总体来说，本次试验不太好做，期间出现了很多逻辑错误，变量初始化的问题等，不过经过仔细排查最后都一一解决了。
实验四：查找与排序
【实验目的】
（1） 掌握折半查找算法的实现。 （2） 掌握冒泡排序算法的实现。 【实验内容】
1.编写折半查找程序，对以下数据查找37所在的位置。5，13，19，21，37，56，64，75，80，88，92 2.编写冒泡排序程序，对以下数据进行排序。 49，38，65，97，76，13，27，49 【实验步骤】 1.打开VC++。
2.建立工程：点File->New，选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK->finish。至此工程建立完毕。
3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File。给文件起好名字，选好路径，点OK。至此一个源文件就被添加到了你刚创建的工程之中。
4．写好代码
5．编译－＞链接－＞调试
（1）查找算法的代码如下所示： #include \"stdio.h\" #include \"malloc.h\" #define OVERFLOW -1 #define OK 1 #define MAXNUM 100 #define N 10 typedef int Elemtype; typedef int Status; typedef struct {
Elemtype *elem;
int length; }SSTable; Status InitList(SSTable &ST ) { int i,n;
ST.elem =
(Elemtype*)
malloc (Elemtype));
if (!ST.elem) return(OVERFLOW);
printf(\"输入元素个数和各元素的值:\");
scanf(\"%d\\n\",&n);
for(i=1;i
(MAXNUM*sizeof
scanf(\"%d\",&ST.elem[i]); }
ST.length = n;
return OK; } int Seq_Search(SSTable ST,Elemtype key) {
int i;
ST.elem[0]=key;
for(i=ST.length;ST.elem[i]!=key;--i);
return i; } int BinarySearch(SSTable ST,Elemtype key) {
int mid,low,high,i=1;
low=1;
high=ST.length;
while(low
{
mid=(low+high)/2;
if(ST.elem[mid]==key)
return mid;
else if(key
high=mid-1;
else
}
return 0; } void main() { SSTable ST; InitList(ST);
Elemtype key; int n; printf(\" key= \");
scanf(\"%d\",&key);
printf(\"\\n\\n\");
/*printf(\"After SeqSearch:: \");
n=Seq_Search(ST,key);
printf(\"position is in %d \\n\\n\",n);*/
printf(\"After Binary Search::\");
n=BinarySearch(ST,key);
low=mid+1; if(n) printf(\"position is in %d \\n\\n\",n); else
} 实验结果如下所示：
（2）排序算法的代码如下所示： #include \"stdio.h\" #include \"malloc.h\" #define OVERFLOW -1 #define OK 1 #define MAXNUM 100 #define N 10 typedef int Elemtype; typedef int Status; typedef struct {
Elemtype *elem;
int length; }SSTable; Status InitList(SSTable &ST ) printf(\"not in \\n\\n\"); { int i,n;
ST.elem (Elemtype));
if (!ST.elem) return(OVERFLOW);
printf(\"输入元素个数和各元素的值:\");
scanf(\"%d\\n\",&n);
for(i=1;i
scanf(\"%d\",&ST.elem[i]); }
ST.length = n;
return OK; } void Sort(SSTable ST) {
int i,j,t;
for(i=1;i
for(j=i+1;j
if(ST.elem[i]>ST.elem[j]) { t=ST.elem[i]; =
(Elemtype*)
malloc
(MAXNUM*sizeof
}
} ST.elem[i]=ST.elem[j]; ST.elem[j]=t; void display(SSTable ST) { int i;
for(i=1;i
printf(\"%d
\",ST.elem[i]); }
} void main() {
SSTable ST; InitList(ST); int n; printf(\"before sort::\\n\"); display(ST); Sort(ST); printf(\"\\nafter sort::\\n\"); display(ST); } 实验结果如下所示：
【实验心得】
通过这次实验,我明白了程序里的折半查找和冒泡查找.其实排序可以有很多种，但是其目的应该都是为了能够在海量的数据里迅速查找到你要的数据信息，折半查找是种比较快的方式，但前提是要是有 序的排序才可以。对于有序表，查找时先取表中间位置的记录关键字和所给关键字进行比较，若相等，则查找成功；如果给定值比该记录关键字大，则在后半部分继续进行折半查找；否则在前半部分进行折半查找，直到查找范围为空而查不到为止。折半查找的过程实际上死先确定待查找元素所在的区域，然后逐步缩小区域，直到查找成功或失败为止。算法中需要用到三个变量，low表示区域下界，high表示上界，中间位置mid=(low+high)/2.而冒泡查找则是从小到大的排序.
第15篇：数据结构
数据结构】二叉排序树的建立，查找，插入和删除实践题 /*sy53.c*/
#include
#include
typedef int KeyType;
typedef struct node{
KeyType key;
struct node *lchild,*rchild;
}BSTNode;
typedef BSTNode *BSTree;
BSTree CreateBST(void);
void SearchBST(BSTree T,KeyType Key);
void InsertBST(BSTree *Tptr,KeyType Key);
void DelBSTNode(BSTree *Tptr,KeyType Key);
void InorderBST(BSTree T);
main()
{BSTree T;
char ch1,ch2;
KeyType Key;
printf(\"建立一棵二叉排序树的二叉链表存储\\n\");
T=CreateBST();
ch1=\'y\';
while (ch1==\'y\' || ch1==\'Y\')
{printf(\"请选择下列操作：\\n\");
printf(\"1------------------更新二叉排序树存储\\n\");
printf(\"2------------------二叉排序树上的查找\\n\");
printf(\"3------------------二叉排序树上的插入\\n\");
printf(\"4------------------二叉排序树上的删除\\n\");
printf(\"5------------------二叉排序树中序输出\\n\");
printf(\"6------------------退出\\n\");
scanf(\"\\n%c\",&ch2);
switch (ch2)
{case \'1\':T=CreateBST();break;
case \'2\':printf(\"\\n请输入要查找的数据：\");
scanf(\"\\n%d\",&Key);
SearchBST(T,Key);
printf(\"查找操作完毕。\\n\");break;
case \'3\': printf(\"\\n请输入要插入的数据：\");
scanf(\"\\n%d\",&Key);
InsertBST(&T,Key);
printf(\"插入操作完毕。\\n\");break;
case \'4\': printf(\"\\n请输入要删除的数据：\");
scanf(\"\\n%d\",&Key);
DelBSTNode(&T,Key);
printf(\"删除操作完毕。\\n\");break;
case \'5\': InorderBST(T);
printf(\"\\n二叉排序树输出完毕。\\n\");break;
case \'6\':ch1=\'n\';break;
default:ch1=\'n\';
}
}
}
BSTree CreateBST(void)
{BSTree T;
KeyType Key;
T=NULL;
printf(\"请输入一个关键字(输入0时结束输入)：\\n\"); scanf(\"%d\",&Key);
while (Key)
{InsertBST(&T,Key);
printf(\"请输入下一个关键字(输入0时结束输入)：\\n\"); scanf(\"\\n%d\",&Key);
}
return T;
}
void SearchBST(BSTree T, KeyType Key)
{ BSTNode *p=T;
while(p)
{if(p->key==Key)
{printf(\"已找到\\n\");
return;
}
p=(Key
}
printf(\"没有找到\\n\");
}
void InsertBST(BSTree *T,KeyType Key)
{BSTNode *f,*p;
p=(*T);
while(p)
{if(p->key==Key)
{printf(\"树中已有Key不需插入\\n\");
return;
}
f=p;
p=(Key
}
p=(BSTNode*)malloc(sizeof(BSTNode));
p->key=Key;
p->lchild=p->rchild=NULL;
if ((*T)==NULL) (*T)=p;
else if (Keykey) f->lchild=p;
else f->rchild=p;
}/*InsertBST*/
void DelBSTNode(BSTree *T,KeyType Key)
{BSTNode *parent=NULL, *p, *q,*child;
p=*T;
while(p)
{if(p->key==Key) break;
parent=p;
p=(Key
}
if (!p) {printf(\"没有找到要删除的结点\\n\");return;}
q=p;
if (q->lchild && q->rchild)
for (parent=q,p=q->rchild; p->lchild; parent=p,p=p->lchild); child=(p->lchild)?p->lchild:p->rchild;
if (!parent) *T=child;
else {if (p==parent->lchild)
parent->lchild=child;
else parent->rchild=child;
if (p!=q)
q->key=p->key;
}
free(p);
}
void InorderBST(BSTree T) { if(T!=NULL)
{InorderBST(T->lchild); printf(\"%5d\",T->key); InorderBST(T->rchild); }
}
第16篇：数据结构实验二 求解约瑟夫问题
数据结构实验二
求解约瑟夫问题
问题描述：使用代表头节点的循环单链表解决此问题。设有n个人围坐在一张圆桌周围，现从某个人开始从1报数，数到m的人离开。接着从出列的下一个人开始重新从1开始报数，数到m的人又出列，如此下去直到所有的人都出列为止。求出他们的出列序列。
问题分析：例如，当n=8,m=4时，若从第一个人开始报数（设从1开始编号），则得到的序列是：4，8，5，2，1，3，7，6。 算法：
void Josephus ( int n, int m,int s )
{ //生成表头节点，空单循环链表
LNode * HL = new LNode ;
HL ->next = HL ;
int i ; //生成含有 n 个节点的、节点值依次为1，2……，n的带表头节点的循环单链表
For ( i = n ; i>=1; i-- )
{ LNode * newptr = new LNode;
Newptr ->data = i ;
newptr ->next = HL ->next ;
HL ->next = newptr ; }
//从表头开始顺序查找出第s个节点，对应第一个开始报数的人 LNode * ap = HL, *cp = HL ->next ; for ( i= 1; i
ap = cp;
cp = cp->next; if ( cp = = HL ) { ap = HL; cp = HL->next ; } } //依次使n-1个人出列 for ( i=1; i
//顺序查找出待出列的人，即为循环结束后cp所指向的节点
for ( int j=1; jnext ; if ( cp ==HL) { ap = HL; cp = HL->next ; } } //输出cp节点的值，即出列的人
cout data
“ ; //从单链表中删除cp节点
ap ->next = cp ->next ; delete cp; //使cp指向被删除节点的后续节点
cp = ap ->next ; //若cp指向了表头节点，则后移ap和cp指针 if ( cp = = HL ) { ap = HL ; cp = HL->next ; } }
//使最后一人出列
count next ->data
//删除表头节点和表头附加节点
delete HL->next ;
delete HL ; }
补充操作系统练习：
1、有一个虚拟存储系统, 每个进程在内存占有3页数据区、1页程序区.刚开始时数据区为空.有以下访页序列:
1、
5、
4、
1、
2、
3、
2、
1、
5、
4、
2、
4、
6、
5、1
试给出下列情形下的缺页次数:
(1)系统采用先进先出(FIFO)淘汰算法.
(2)系统采用最近最少使用(LRU)淘汰算法.
(3)若采用优化(OPT)淘汰算法呢?
2、设系统中有三类资源A、B和C，又设系统中有5个进程P1，P2，P3，P4和P5.在T0时刻系统状态如下：
最大需求量
已分配资源量
剩余资源量
A
B
C
A
B
C
A
B
C
P1 8
P2 4
P3 10 1
P4 3
P5 5
3 (1) 系统是否处于安全状态？如是，则给出进程安全序列.(2) 如果进程P5申请1个资源类A、1个资源类B和1个资源类C，能否实施分配？为什么？
3、在一个两道的批处理操作系统中，有6个作业进入系统，它们的进入时刻、估计运行时间和优先级如下表所示.
作业号
进入时刻
估计运行时间
优先级
JOB1
8：00
90分钟
JOB2
8：10
30分钟
JOB3
8：30
20分钟
JOB4
8：50
15分钟
JOB5
9：20
10分钟
JOB6
9：40
5分钟
4 系统采用短作业优先作业调度算法，作业一旦被调度运行就不再退出.但当有新的作业投入运行时，可以按照优先级进行进程调度.（1） 试给出各个作业的运行时间序列.（例如：JOB1：8：00-8：30，9：10-9：20，…）
（2） 试计算出作业的平均周转时间.
第17篇：数据结构课程设计 背包问题的求解
2009届 电子信息科学与技术专业 数据结构课程设计
背包问题的求解
摘
要 组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点，这不仅在于其内在的复杂性有着重要的理论价值，同时也在于它们能在现实生活中广泛的应用。背包问题是一个典型的组合优化问题，本课程设计用递归算法求解背包问题，就是在资源有限的条件下，追求总的最大收益的资源有效分配问题。 关键词 背包问题；
递归算法；
1问题描述
1.1问题描述
背包问题：设有不同价值、不同重量的物品n件，求从这n件物品中选取一部分的方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。
1.2基本思想
（1）分别输入n件物品的重量和价值。 （2）采用递归寻找物品的方案。
（3）输出最佳的装填方案，包括选中的是哪几种物品，总价值为多少。
2问题分析
背包问题的求解是一个很经典的案例。对于它的分析与研究已经到达了一定的深度，解决这个问题有很多很多的办法。其中递归方法是比较简化程序，也比较难理解的一个。
设n件物品的重量分别为w0,w1,„,wn-1,物品的价值分别为v0,v1,„,vn-1。采用递归寻找物品的选择方案。设前面已经有了多种选择方案，并保留了其中最大的选择方案于数组option[],设方案的的总价值存于变量maxv,当前正在考察新方案其物品选择情况保存于数组cop[]，嘉定当前方案已经考虑了前i-1件物品，现在正在考虑第i件物品；当前方案已经包含的物品的质量之和为tw;至此，若其余物品都选择可能的话，本方案能达到的总价值的期望值设为tv，算法引入tv是当一旦当前方案的总价值的期望值也小于前面方案的总价值maxv时，急需考察当前方案变成无意义的工作，应终止当前方案，立即去考察下一个方案。因为当方案的总价值不比maxv大时，该方案不会不会再被考察。这同时保证函数后找到的方案一定会比前面的方案更好。
1 2009届 电子信息科学与技术专业 数据结构课程设计 对于第i件物品的选择有两种可能：
（1）物品i被选择，这种可能性仅当包含它不会超过方案总重量的限制时才是可行的。选中后，继续递归去考虑其余物品的选择；
（2）物品i不被选择，这种可能性仅当不包物品i也有可能会找大价值更大的方案的情况。
就此，通过不断地对从第一件开始的物品到第n件物品进行选择或是不选择，从而从各个方案的比较中选择出最优方案。
采用option[]和cop[]两个数组，来辅助完成递归寻找物品的选择方案。数组option[]起到一个“旗帜”作用，用来区别于未被选择的物品，从而达到输出被选择的函数。而cop[]则像是一个中间变量，它在递归过程中不断地发生变化，将有效的最终数据传输给数组option[]，起到一个桥梁作用。
3数据结构描述
背包问题结构体：
struct{
int weight;
int value;
}a[N]; 4算法设计
4.1程序流程图
2 2009届 电子信息科学与技术专业 数据结构课程设计
图4-1 程序流程图
4.2算法设计
根据问题分析中的思想写出递归算法如下：
find（物品当前选择已达到的重量和tw,本方案可能达到的总价值为tv） ｛
/*考虑物品i包含在当前方案中的可能性*/ if（包含物品i是可接受的） ｛
将物品i包含在当前方案中；
if(i
以当前方案作为临时最佳方案保存；
恢复物品i不包含状态；
｝
3 2009届 电子信息科学与技术专业 数据结构课程设计
/*考虑物品i不包含在当前方案中的可能性*/ if（不包含物品i仅是可考虑的）
if(i
以当前方案作为临时最佳方案保存；
｝
void find(int i,int tw,int tv)
{ int k; if(tw+a[i].weight
/*物品i包含在当前方案的可能性*/ { cop[i]=1; if(imaxv)
/*物品i不包含在当前方案的可能性*/ if(i
4 2009届 电子信息科学与技术专业 数据结构课程设计
opion[k]=cop[k]; maxv=tv-a[i].value; } } 5详细程序清单
详细程序清单见附录。
6程序运行结果
背包问题求解界面如图6-1所示。
图6-1 背包问题求解界面
程序调试成功。
在课程设计代码调试过程中也出了不少差错，比如头文件很容易忽略，同学指出才发现；一些符号像“；”也很容易丢掉或是中英文格式不正确；甚至像0和 O这种小错误有时也会发生，在经过调试和完善程序的过程中，这些错误已经全部改正。在此过程中我们学到了不少调试的技巧，极大得丰富了编程的知识，这些在程序的优化方面帮助很大。
7心得体会
通过此次课程设计的实践，感触较深。不仅使我们加深了对书本知识的理解，而且锻炼了我们编写程序、调试程序的能力。同时，此次课程设计也充分弥补了课堂教学中知识的缺陷。这次课程设计由于时间有限，对有些地方考虑的还不够周到。
5 2009届 电子信息科学与技术专业 数据结构课程设计
在本课题中，我们研究了如何用递归算法求解组合优化问题中的背包问题，背包问题是一个典型的组合优化问题，就是在资源有限的条件下，追求总的最大收益的资源有效分配问题。所以我们试着用所学的数据结构知识以及递归法来解决普通的背包问题。背包问题的递归思想确实有点难以理解，为了理解这个思想，我们确实花了很长时间，不过很高兴最后经过我们的讨论掌握了这个思想。
参考文献
[1] 徐孝凯.数据结构课程实验.北京：清华大学出版社，2002:100-132 [2] 张乃笑.数据结构与算法.北京：电子工业出版，2000:3-5 [3] 严蔚敏.数据结构（C语言版）.北京： 清华大学出版社，2002:100-132 [4] 李春葆.数据结构（C语言篇）习题与解析（修订版）.北京：清华大学出版，2000:45-66
Knapsack problem solving
Li Shuai Zhu Zhili Kong Rongong (Department of Physics ,Dezhou University,Dezhou,253023) Abstract Combinatorial optimization problem solving method has become the focus of attention of the scientific, it not only lies in its inherent complexity has the important theoretical value, but also that they can in real life widely.Knapsack problem is a typical combinatorial optimization problem, the course is designed to use recursion algorithm for solving knapsack problem was under the condition of limited resources, the pursuit of the maximum benefit of the resources allocation problem.Keywords knapsack problem; recursive algorithm
6 2009届 电子信息科学与技术专业 数据结构课程设计
附录：详细程序清单
#include #define N 100 int limitw,
/*限制的总重量*/ totv,
/*全部物品的总价*/ maxv;
/*可实现最大总价值*/ int opion[N],
cop[N];
struct{
int weight;
int value;
}a[N]; int n;
void find(int i,int tw,int tv)
{ int k; if(tw+a[i].weight
{ cop[i]=1; if(i
/*方案的选择*/ /*当前方案的选择*/ /*背包问题结构体*/
/*物品种数*/ /*物品i包含在当前方案的可能性*/ 7
2009届 电子信息科学与技术专业 数据结构课程设计
if(tv-a[i].value>maxv)
/*物品i不包含在当前方案的可能性*/ if(i
第%d种物品（重量，价值）：\",k+1); scanf(\"%d,%d\",&w,&v); a[k].weight=w; a[k].value=v; totv+=v; } printf(\"背包所能承受的总重量：\"); scanf(\"%d\",&limitw); maxv=0; for(k=0;k
printf(\"最佳装填方案是：\\n\"); for(k=0;k
第18篇：第二季度计划编制说明
季度计划编制说明
（以温州项目二季度计划为例）
一、第一季度计划完成情况
1、一季度计划完成产值4967.16万元，实际完成施工产值 2380.24万元，占计划的47.5%。具体完成情况见《二季度施工产值计划表》
2、一季度完成的主要形象进度及至一季度末累计完成的主要形象进度见《二季度主要形象进度计划表》。
3、第一季度中未完成计划的主要原因分析：
(1)、路基工区因政策性原因，征地至今不能交付，造成路基几乎处于停工状态，没有完成计划目标。
(2)、西引桥1～6＃墩的厂房、东引桥21～30＃墩四层楼民房及部分厂房均未拆迁，多达16个墩无法进行施工，没有完成计划目标。
(3)、桩基础施工因受地质结构和嵌岩深度的制约，难度较大，影响了施工进度，没有完成计划目标。
（4）工程款的计量支付周期长，第1期计量款至今没有落实，制约了经理部的生产。
二、第二季度施工生产计划
1、二季度计划完成施工产值6781.34万元，
4、
5、6月计划产值分别为1882.7
3、2046.8
2、2851.78万元。具体计划情况见《二季度施工产值计划表》。
2、二季度主要形象进度计划见《二季度主要形象进度计划表》。
3、项目完成计划应重点保证的节点目标：
（1）欧江大桥主桥施工：应保证至6月底完成基桩100%，完成主墩承台2个，完成墩身2个，一个主墩开始0#块支架施工；力争4个主墩承台全部完成。
（2）欧江大桥西引桥施工：应保证至5月中旬完成左幅2个墩身（6#-7#墩），从而开始移动模架的拼装施工，在6月底完成1孔现浇箱梁施工（6#-7#墩左幅）。
（3）欧江大桥东引桥施工：应保证至6月底墩身、盖梁连续完成3-5孔，箱梁预制完成40片/277片，梁架设完成10片。
（4）路基施工：应在二季度全线开工，至6月底应保证完成全部软基处理工程，完成路基挖方10万m3/59万m3，完成路基填方9万m3/55万m3。
（5）隧道施工：至保证至6月底完成右幅洞身开挖560m/860m，完成左幅洞身开挖360m/860m。争取右幅开挖7月底完成，左幅开挖9月底完成。
三、本季度施工应重点解决的问题
尽快落实解决红线范围内政策性问题。路基工区、桥梁工区的厂房和民房的拆除，有关征地问题，高压线改线问题，
水管的改迁问题。
四、本季度施工应重点采取的安全保证措施
温州项目二季度的施工要注意收集当地的潮流信息，在承台施工中要注意潮流的涨退时间，认真做好现场的生产安排，避开大潮汛对现场施工的影响。在4月底前总结去年的现场施工经验，完善经理部的防台防汛预案报公司审核。在二季度完成防台防汛的物资准备和储备。
附件：
1、第二季度施工产值计划表
2、第二季度主要形象进度计划表
二OO六年四月八日
第19篇：采购计划编制要求
采购计划编制要求
第1条采购计划的编制依据主要包括以下七项内容。
1．销售计划。
2．生产计划。
3．其余各部门的物料需求计划。
4．物料库存报表。
5．购买物料的厂商及市场状况。
6．采购计划的历史数据及上期执行状况。
7．工厂资金供应能力及采购预算。
第2条采购计划的编制原则。
1．量力而行原则。编制的采购计划要严格按照预算执行并考虑到工厂的及时支付能力。
2．适度超前原则。编制采购计划时要充分考虑物料的先进性，考虑物料的现实需求与前瞻需求，在工厂财力允许的情况下，适度提高采购物料的余量与内在品质。
3．成本经济型原则。编制采购计划时充分考虑采购物料与其后续成本支出，按照降低采购成本的总要求，合格地确定规格型号等具体的技术参数。
4．物料分类原则。编制采购成本时需要将采购的物料按照轻重缓急分为不同的等级，对重点物料或急需物料要确保优先安排采购。
5．提高采购整体效益原则。
（1）对采购价格容易随季节变化的物料，编制采购计划时应将其安排在价格处于低谷的淡季进行采购。
（2）对相近或相同的物料采购，编制采购计划时尽量安排一次性采购。
（3）对经过认证能够满足工厂需求的供应商，编制采购计划时尽量将不同的产品安排在一个供应商名下进行集中采购。
第3条采购计划的内容。
1．采购物料的数量、技术规格、参数及要求。
2．采购物料的价格及供应商。
3．采购物料在生产中的投入使用阶段。
4．采购的全部物料划分模块的标准及每个模块下包含的项目。
5．编制每个采购模块在采购过程中各个阶段的时间表，并根据每个模块的采购时间表确定全部采购的时间表，并及时通知相关部门。
6．整个采购工作的协调管理工作。
第4条销售部门应将销售计划、销售预测通知采购部，仓库应根据生产计划及相关库存报送采购部，方便采购部编制采购计划及采购预算。其他部门的需求计划按照生产部计划的报送转交时间统一报告给采购部。
第5条采购部在收齐所有的物料需求信息后，应根据工厂产品的行业特点、实际工作需要及工厂目前的物料配置，认真分析物料的需求情况，并结合工厂的财务状况对物料的需求采取必要的调整措施。
第6条采购部编制采购计划之前必须根据收集、整理的资料编制采购预算，采购计划的编制要严格控制在采购预算的范围内。
第7条采购部制订出的采购计划草案应征求各个生产车间及相关部门的意见，各生产车间及相关部门根据工作实际情况分析采购计划的可行性并提出建议或意见。
第8条采购计划中每种产品的供应商必须经过工厂的认证，采购计划确认后报主管及总经理审核。
第20篇：计划编制假设条件
计划编制主要假设条件
1、根据项目开发条件实际情况，结合工程施工组织、营销推盘思路等因素（见附件《青岛蓝海新港城项目开发时序说明》），确定开发时序为：
一期：A、B地块（A区按地下2层，2层裙楼，34层标准层计算工期；B区按地下4层，2层裙楼，30层标准层计算工期）；
二期：C、D地块（按地下2层，2层裙楼，30层标准层计算工期），G地块轮渡区（按地下2层，地上1层，需地基处理考虑）；
三期：J地块（按地下4层，2层裙楼，39层标准层计算工期）；
四期：H、F、E地块（按地下4层，1层裙楼，58层标准层计算工期）。
因单体方案未明确，以上按各楼座不考虑转换层，按区块楼栋同步施工，各楼座为精装修假设条件考虑计划。
2、计划排期日历采用“无休息日工作日历”，除考虑春节假休外，未考虑其他休息日及雨、冬季影响情况。
3、楼层施工按平均7天/层考虑，地下施工按20-30天/层考虑；招采工作按25-30天/项考虑。
4、未考虑施工开展与施工许可证之间的逻辑关系，售楼处在无临设施工许可证下建设，一期、二期在无施工许可证下施工（至主体结构至十几层）。取证延后达6个月，属于违规施工，期间存在着极大政策风险。
5、
一、二期报规图、施工图同步设计推进，连续报审。施工开展在未通过“施工图审查”条件下进行。属于快速跟进做法，需要对报批成果对把握程度高，努力降低变更风险，导致返工和工期延误、成本浪费。
6、C地块拆迁要求在7月31日前完成，具备土护降施工条件。其他区块拆迁按不影响项目进展考虑。
7、轮渡协议签订完成、轮渡以北土地注入、J地块具备轮渡临时使用为G地块提供施工条件，必须在2011年7月30日前完成。
8、未考虑施工用临水、临电影响。临水、临电条件：（1）公司资质；（2）建筑工程规划方案得到批复。正式条件在2012年2月具备。需要做内部工作完成。
9、售楼处与样板间的结合问题，按后补样板间考虑。
10、售楼处属于临建，需要在《建设工程规划许可证》办理后有临建许可手续，本计划未考虑。属于违规施工，期间存在着极大政策风险。
11、人防方案按人防不设置在一期项目考虑，获取人防方案批复后即启动结构施工。
