数据结构课程设计报告(模拟电梯)
数据结构 电梯模拟的报告
1．课程设计目的1、训练学生灵活应用所学数据结构知识，独立完成问题分析，结合数据结构理论知识，编写程序求解指定问题。
2.初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力；4.训练用系统的观点和软件开发一般规范进行软件开发，巩固、深化学生的理论知识，提高编程水平，并在此过程中培养他们严谨的科学态度和良好的工作作风。
2．课程设计任务与要求：任务根据教材《数据结构题集（C语言版）》（严蔚敏、吴伟民主编）选择课程设计题目，要求通过设计，在数据结构的逻辑特性和物理表示、数据结构的选择应用、算法的设计及其实现等方面加深对课程基本内容的理解和综合运用。
设计题目从《数据结构题集》“第二篇实习篇”中选取，每班每题不得超过2人。
另选题：学生自选课题学生原则上可以结合个人爱好自选课题，要求课题有一定的深度与难度，有一定的算法复杂性，能够巩固数据结构课程所学的知识。
学生自选课题需在17周前报课程设计指导教师批准方可生效。
要求：1、在处理每个题目时，要求从分析题目的需求入手，按设计抽象数据类型、构思算法、通过设计实现抽象数据类型、编制上机程序和上机调试等若干步骤完成题目，最终写出完整的分析报告。
前期准备工作完备与否直接影响到后序上机调试工作的效率。
在程序设计阶段应尽量利用已有的标准函数，加大代码的重用率。
2、.设计的题目要求达到一定工作量（300行以上代码），并具有一定的深度和难度。
3、程序设计语言推荐使用C/C++，程序书写规范，源程序需加必要的注释;4、每位同学需提交可独立运行的程序；5、每位同学需独立提交设计报告书（每人一份），要求编排格式统一、规范、内容充实，不少于10页（代码不算）；6、课程设计实践作为培养学生动手能力的一种手段，单独考核。
数据结构课程设计报告第5页，共页数据结构课程设计报告第13页，共页数据结构课程设计报告第19页，共页数据结构课程设计报告第20页，共页。
电梯模拟课程设计方案模板
随着城市化进程的加快，电梯作为一种重要的交通工具，其安全性和智能化程度日益受到重视。
为了让学生更好地了解电梯的工作原理、控制方法及维护保养，本课程设计旨在通过模拟电梯运行，让学生在理论与实践相结合的过程中，掌握电梯相关知识和技能。
二、课程目标1. 理解电梯的基本组成和工作原理；2. 掌握电梯控制系统的编程方法；3. 熟悉电梯的维护保养流程；4. 培养学生的创新思维和团队协作能力。
三、课程内容1. 电梯基本知识（1）电梯的组成及工作原理；（2）电梯的驱动方式及控制系统；（3）电梯的运行参数及安全标准。
2. 电梯控制系统设计（1）PLC编程基础；（2）电梯控制系统的硬件设计；（3）电梯控制系统的软件设计；（4）电梯控制系统的调试与优化。
3. 电梯维护保养（1）电梯的日常维护保养；（2）电梯的故障排除及应急处理；（3）电梯的定期检修与维护。
1. 教学方法（1）理论教学：采用多媒体教学手段，结合实物展示，使学生了解电梯的基本知识；（2）实践教学：通过模拟电梯运行，让学生亲自动手操作，掌握电梯控制系统的编程、调试与优化；（3）项目教学：以实际电梯为例，让学生参与电梯维护保养的全过程，提高学生的实际操作能力。
2. 教学过程（1）课堂讲授：教师讲解电梯基本知识、控制系统设计及维护保养等内容；（2）实验操作：学生在教师指导下，完成电梯控制系统的编程、调试与优化；（3）项目实践：学生分组进行电梯维护保养，完成项目任务。
五、课程评价1. 课堂表现：学生出勤率、课堂纪律及参与度；2. 实验操作：学生完成电梯控制系统的编程、调试与优化情况；3. 项目实践：学生参与电梯维护保养的项目完成情况；4. 期末考核：理论考试、实践操作考核及项目答辩。
六、课程总结通过本课程设计，学生能够全面了解电梯的相关知识，掌握电梯控制系统的编程、调试与优化方法，以及电梯的维护保养流程。
同时，培养学生的创新思维和团队协作能力，为今后从事电梯行业打下坚实基础。
模拟电梯问题实验报告
电梯模拟问题一、目的与要求1. 掌握线性结构的逻辑特点及存储实现；2. 根据选题，按规范化流程完成课程设计报告：⑴．提供需求分析。
（15分）⑵．列出概要设计。
（包括：抽象数据类型的描述；程序结构图或功能模块图）（20分）⑶．给出详细设计。
（包括：①存储结构的描述；②算法的详细设计，对复杂算法，最好画出其N-S流程图；③函数的调用关系图）（30分）⑷．进行调试分析（注：调试时遇到的问题及解决方法，程序的输出结果及对结果的分析）。
（15分）⑸. 整理设计总结。
（设计心得体会，以及其他总结信息等）（10分）⑹．附有程序清单（注：代码可具有适当注释，用来说明程序的功能、结构）。
（10分）二、设计步骤1、线性结构是有序数据元素的集合，存在着“一对一”的线性关系且只有一个首结点，一个尾结点，首结点只有后继没有前趋，尾结点只有前趋没有后继。
顺序表的存储结构包括顺序表和链表，顺序存储是指将线性表元素按照逻辑顺序依次存储在一组连续的地址单元中。
链式存储是通过结点中的链域将线性表中n个结点按其逻辑顺序链接在一起。
分为：单向链表，双向链表，循环链表。
2、（1）设计一个电梯模拟系统。
这是一个离散的模拟程序，因为电梯系统是乘客和电梯等“活动体”够成的集合，虽然他们彼此交互作用，但是他们的行为是基本独立的。
在离散的模拟中，一模拟时钟决定每个活动体的动作发生的时刻和顺序，系统在某个模拟瞬间处理有待完成的各种事情，然后把模拟时钟推进到某个动作预定要发生的下一个时刻。
可模拟某校五层教学楼的电梯系统，或者九层教学楼的电梯系统。
此程序的关键是模拟好电梯运行状态的转换与乘客进出的同步进行，需要一个函数判断电梯的运行状态，决定电梯的下一个运行状态如电梯的开门，关门，上升，下降，减速，加速等，也需要模拟时钟的函数来判断该运行哪个函数，也需要定义几个结构体存放结点信息。
（2）时钟函数：void DoTime(){//此函数用于模拟时钟while(1){if(Time>MaxTime)return;TestPeople();//两个始终都会被调用的函数Controler();struct Activity* p=activity.next;if(p==NULL){Time=MaxTime;}if(p&&Time>=p->time){//取出活动队头的，检测定时是否到了activity.next=p->next;p->fn();free(p);}Time++;}}其中activity是关键，它是一个链表在链表的头部是计时器时间最小的函数，根据模拟时钟判断是否调用这个函数以及删除这个节点。
java课程设计报告(模拟电梯系统)
Java课程设计报告组号：第四组课题名称：模拟电梯调度班级：09计一课题组成员姓名及学号：09030101课程设计日期：2011.6.20－2011.6.24地点：秋白楼B720一．正文1）[课程设计目的与要求]○1目的掌握线程的应用及线程在多媒体中的使用，了解线程的运行机制和线程的新建、就绪、运行、挂起、死亡五种状态，对线程由新的认识和巩固。
熟练java的动画编程，理解repaint()方法的调用过程及如何通过改写update()方法和双缓冲技术消除动画中出现的闪烁现象。
理解java的容器和组件的应用。
掌握java的事件处理机制：实现ActionListener接口，对事件源添加侦听器，实现actionPerformed()方法用以处理事件源所产生的事件。
另外使组员能够针对具体的有一定代表性的小型综合应用类课题设计、分析，全面掌握面向对象的思想、JAVA语言的应用技巧、方法，从而使组员进一步理解和掌握利用JAVA开发综合系统的过程，学会用java开发工具，同时培养组员的合作意识和团队精神，培养学生对实际系统的采用面向对象的方法进行分析与设计能力，从而使学生提高JAVA语言运用与开发的综合能力。
○2需求分析模拟电梯调度：有一栋三层的楼房，楼内有三个电梯。
要求电梯实现可以正常上下，和到达目的楼层后即停留并且实现开门及关门动作。
电梯需有多层停留功能即：当对同一个电梯需要其在多层都有下客时，电梯要在有下客动作的楼层停留然后自动去下一个有下客动作的楼层，而不需要乘客在次发出请求。
电梯具有距离发出请求的楼层最近的电梯响应请求的功能即：当某一楼层有乘客需要使用电梯时，由距离该楼层最近的电梯去响应，而不是任意一个电梯都可以响应。
（注：当存在距离该楼层最近的电梯且该电梯正在远离该楼层运动时该电梯不响应，当存在多个电梯距离该楼层最近时由编号低的电梯响应而不是全都响应。
2）[本人在课程设计中承担的任务]在课程设计中我主要负责事件处理，并判断该事件是何种事件，需要做出怎样的响应。
电梯模拟课程设计
课程设计实验报告课程名称__数据结构__题目名称电梯模拟专业班级学号学生姓名指导教师_2011 年1 月日一、需求分析及实现提示[需求分析]（1）、模拟某校五层教学楼的电梯系统。
该楼有一个自动电梯，能在每层停留。
五个楼层由下至上依次称为地下层、第一层、第二层、第三层和第四层，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来该层候命。
（2）、乘客可随机地进出于任何层。
对每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
（3）、模拟时钟从0开始，时间单位为0.1秒。
人和电梯的各种动作均要耗费一定的时间单位（简记为t）：有人进出时，电梯每隔40t测试一次，若无人进出，则关门关门和开门各需要20t每个人进出电梯均需要25t如果电梯在某层静止时间超过300t，则驶回1层候命。
（4）、按时序显示系统状态的变化过程：发生的全部人和电梯的动作序列。
[实现提示]（1）楼层由下至上依次编号为0，1，2，3，4。
每目有要求Up(上)和Down(下)的两个按钮，对应l0个变量CallUp[0．．4]和CallDown[0．．4]。
电梯内5个目标层按钮对应变量CallCar[0．．4]。
有人按下某个按钮时，相应的变量就置为1，一旦要求满足后，电梯就把该变量清为0。
（2）电梯处于三种状态之一：GoingUp(上行)、GoingDown(下行)和IdIe(停候)。
如果电梯处于IdIe状态且不在1层，则关门并驶回1层。
在1层停候时，电梯是闭门候命。
一旦收到往另一层的命令，就转入GoingUp或GoingDown状态，执行相应的操作。
（3）用变量Time表示模拟时钟，初值为0，时间单位(t)为0.1秒。
其他重要的变量有：Floor——电梯的当前位置(楼层)；D1——值为0，除非人们正在进入和离开电梯；D2——值为0，如果电梯已经在某层停候300t以上；D3——值为0，除非电梯门正开着又无人进出电梯；State——电梯的当前状态(GoingUp，GoingDown，IdIe)。
操作系统课程设计-模拟电梯调度算法 实现对磁盘的驱动调度
衡阳师范学院操作系统课程设计报告设计题目：驱动调度系别：计算机科学系专业：计算机科学与技术（师范）班级：1001班姓名：XXX学号：XXX指导教师：XXX2012年11月26日目录一、程序设计内容原理及目的·······························1、设计内容················································`2、设计原理·················································3、设计目的·················································二、程序设计过程·········································1、驱动调度中的数据结构设计·································2、程序算法设计··············································三、用户手册··············································1、运行坏境··················································2、执行文件··················································四、程序实现及运行结果····································1、源代码····················································2、代码······················································3、运行结果·················································五、心得总结···············································六、参考文献···············································二、程序设计内容原理及目的1、设计内容模拟电梯调度算法，实现对磁盘的驱动调度。
电梯数据结构课程设计
电梯数据结构课程设计一、教学目标本课程的教学目标是让学生掌握电梯数据结构的基本原理和应用方法。
具体包括：1.知识目标：了解电梯数据结构的基本概念、原理和特点；掌握常用的电梯数据结构及其优缺点；了解电梯数据结构在实际应用中的重要性。
2.技能目标：能够运用电梯数据结构解决实际问题；能够编写相应的程序，实现电梯数据结构的基本操作；能够对电梯数据结构进行性能分析和优化。
3.情感态度价值观目标：培养学生对电梯数据结构的兴趣和好奇心，使其认识到电梯数据结构在现代社会中的重要性；培养学生的问题解决能力和创新精神，使其能够运用电梯数据结构解决实际问题。
二、教学内容本课程的教学内容主要包括以下几个部分：1.电梯数据结构的基本概念和原理：介绍电梯数据结构的基本概念，如线性表、栈、队列、链表等，以及其相应的原理和特点。
2.常用的电梯数据结构及其应用：介绍常用的电梯数据结构，如数组、字符串、栈、队列、链表等，以及其在实际应用中的具体方法和技巧。
3.电梯数据结构的性能分析和优化：分析电梯数据结构的性能，如时间复杂度和空间复杂度，以及如何进行优化和改进。
三、教学方法本课程的教学方法主要包括以下几种：1.讲授法：通过讲解和演示，向学生传授电梯数据结构的基本概念和原理。
2.讨论法：通过小组讨论和问题解答，引导学生深入思考和理解电梯数据结构的应用方法和技巧。
3.案例分析法：通过分析实际案例，让学生了解电梯数据结构在实际应用中的重要性和具体应用方法。
4.实验法：通过编写程序和进行实验，让学生亲手操作和体验电梯数据结构的基本操作和性能。
四、教学资源本课程的教学资源主要包括以下几种：1.教材：选用权威、实用的教材，如《数据结构》等，作为学生学习的主要参考资料。
2.参考书：提供相关的参考书籍，如《算法导论》、《数据结构与算法分析》等，供学生深入学习和研究。
3.多媒体资料：制作精美的PPT课件和教学视频，帮助学生更好地理解和掌握电梯数据结构的基本概念和操作方法。
数据结构(Python课程)课程项目2-1(电梯系统模拟)
数据结构（Python课程）课程项目2-1（电梯系统模拟）（北京大学数学学院，2014年11月20日）本项目要求以项目组为单位独立完成下面工作。
一个项目组由两位同学组成，12月5日前将完成的程序和所写报告（打包）提交辅导老师。
评分要求包括：1. 所提交的程序应该完整，包括一个demo程序（演示程序）展示所开发系统的情况；程序的模块划分和采用的数据结构合理，代码清晰，格式合适，易读易理解；2. 所提交报告对项目工作描述应清晰准确，说明为什么采用有关的结构设计，其中的想法和解决的问题等；报告应包含对所完成的项目的分析，考虑其优点和缺点；3. 在用Python完成这一项目过程中的体会和遇到的困难（本条不作为强制性要求）；4. 其他要求见下面项目说明。
项目描述：请开发一个简单的电梯模拟系统，具体要求如下：假设电梯所在的建筑共计4层（例如，就是目前数学学院所在的一号楼），从地面层（按习惯称1楼）直至最上层（4楼）。
这里的4应该是一个参数，可以修改。
例如可以方便地转去模拟7层楼的电梯（如信息科学技术学院那边）。
每层电梯门边有一个上行按钮和一个下行按钮，最下层和最上层只有一个按钮。
电梯里有一组按钮，供乘电梯人选择目标楼层。
电梯从一层到其相邻层需要k秒时间。
乘客按一定时间间隔到达某楼层，按电梯门边按钮表示要求上行或下行。
乘客到达的时间间隔是区间 [a, b] 里的某个随机值，到达楼层是 [1, 4] 中的随机值。
乘客进电梯后选择搭乘的目标楼层（随机值）。
乘客在电梯到达其目标楼层后离开电梯。
我们希望模拟N秒的电梯运行情况，并在模拟中做一些统计。
考虑下面的数据统计：模拟期间完成服务的共计人数；平均等电梯时间；电梯的平均负荷人数（请提出一种适当的统计方法）；其他有意义的统计结果（自己考虑）。
项目要求：根据题目要求设计并实现所需的功能，1，设计所需的数据结构，根据需要定义有用的类（class）。
例如，用什么数据结构表示乘客、电梯、按钮等，模拟中的各种事件，怎样把它们组织起来形成完整的系统；2，可以参考课堂上给的实例，采用类似的实现技术。
数据结构课程设计：电梯模拟
问题描述：模拟某校九层教学楼的电梯系统。
该楼有一个自动电梯，能在每层停留。
九个楼层由下至上依次称为地下一层、第一层、第二层、……第八层，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来到该层候命。
乘客可随时地进出于任何层。
对于每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
模拟时钟从0开始，时间单位为0.1秒。
人和电梯的各种动作均要消耗一定的时间单位（简记为t），比如：有人进出时，电梯每隔40t检测一次，若无人进出，则关门；关门和开门各需要20t；每个人进出电梯均需要25t；如果电梯在某层精致时间超过300t，则驶回1层候命。
基本要求：按时序显示系统状态的变化过程，即发生的全部人和电梯的动作序列。
需求分析：（1）用系统计时，每当有新的动作要输入时要暂停计时，等输入完成后即可继续计时。
（2）输入各个动作，最后，输入完毕后，可以保存所有动作序列，并有序输出。
设计：设计思想（1）存储结构根据问题描述，可采用单链表结构。
结点描述：定义如下：typedef struct Node{char a[1000];//信息int mytime;//时间struct Node *next;}SLNode;（2）基本思想a.用time.h 里面的clock()来计时，当有输入时，记录下开始输入的时间和结束输入的时间，之后就可以算出动作的时间了。
b.将各个动作发生的时间进行处理，算出每个事件的发生顺序和时间。
c.将各个数据插入链表，即可实现题目要求。
设计表示法（1）过程或函数调用的关系图mainyunxingprintListInsertLinListSort各个动作函数（n个）ge)ListInitiat eDestroy（2）基于数据结构的操作组主要在于yunxing()函数，它将各个时间动作处理成时间事件，并将事件插入到链表中。
（3）过程与接口规格说明无实现注释未实现。
数据结构——电梯模拟的报告
数据结构——电梯模拟的报告数据结构——电梯模拟的报告⒈引言在现代社会，电梯已经成为了人们生活中不可或缺的一部分。
电梯的运行和调度涉及到众多复杂的算法和数据结构。
为了提高电梯的运行效率和用户体验，本报告将介绍一种电梯模拟的数据结构设计。
⒉背景和目标在城市高楼大厦中，电梯的运行和调度是一个极其重要的问题。
每天数以万计的乘客需要借助电梯上下楼，所以我们需要设计一种电梯调度算法来保证乘客能够快速、方便地到达目的地。
本报告旨在介绍一种基于数据结构的电梯模拟方案，提高电梯的运行效率和用户体验。
⒊系统架构在电梯模拟系统中，主要包括以下几个部分：电梯控制器、电梯队列、乘客请求队列和电梯状态管理模块。
电梯控制器负责接收乘客的请求并将其分配给特定的电梯，电梯队列记录电梯所在楼层和运行方向，乘客请求队列保存尚未得到满足的乘客请求，电梯状态管理模块负责监控电梯的状态和运行情况。
⒋数据结构设计⑴电梯队列电梯队列使用循环数组来保存电梯所在楼层和运行方向。
每个电梯对应一个循环数组，数组中的每个元素表示一个楼层的状态，包括空闲、上升和下降。
⑵乘客请求队列乘客请求队列使用链表来保存尚未得到满足的乘客请求。
每个节点表示一个乘客请求，包括乘客所在楼层和目标楼层。
⑶电梯状态管理模块电梯状态管理模块使用状态机来管理电梯的状态和运行情况。
状态机包括电梯的空闲状态、运行状态和停止状态。
⒌算法设计⑴电梯调度算法电梯调度算法负责根据乘客的请求选择最佳的电梯响应。
常用的电梯调度算法包括最短路径算法、最佳负载均衡算法等。
⑵电梯运行算法电梯运行算法负责根据电梯的状态和所运载乘客的请求，确定电梯下一步的行动。
常用的电梯运行算法包括最近停靠楼层算法、深度优先搜索算法等。
⒍实现和测试在本章节中，将介绍电梯模拟系统的实现细节和测试方法。
主要包括编程语言的选择、具体实现算法的具体实现和性能测试。
⒎总结和展望在本章节中，将总结本文提出的电梯模拟方案的优点和不足，提出可能的改进方向，并展望未来可能的研究方向。
数据结构——电梯模拟的报告
数据结构——电梯模拟的报告数据结构——电梯模拟的报告1. 简介本文档将介绍电梯模拟的实现过程和基本原理。
通过模拟电梯的行为，我们可以更好地理解数据结构在实际应用中的作用和效果。
2. 问题描述在楼房中，电梯通常被用来运送乘客。
电梯内部有多个按钮，表示不同楼层的乘客需求。
乘客可以按下按钮来请求乘坐电梯到达特定楼层。
电梯的运行顺序应该是合理的，比如不会从高楼层下降到低楼层。
本模拟的电梯系统需要满足以下要求：- 电梯能接收来自乘客的请求。
- 电梯能根据请求的楼层，按照合理的顺序运行，将乘客送到目标楼层。
- 当电梯到达目标楼层，乘客可以进入或离开电梯。
- 电梯需要实时更新运行状态，如目标楼层、当前楼层等。
3. 数据结构设计为了实现电梯模拟，我们需要设计合适的数据结构来存储电梯的状态和乘客请求。
以下是我们设计的关键数据结构：3.1 电梯状态电梯的状态包括当前楼层、目标楼层和运行方向等信息。
我们可以使用一个结构体来表示电梯的状态：```c++struct ElevatorState {int currentFloor;int targetFloor;Direction direction;};```其中，`currentFloor`表示当前所在楼层，`targetFloor`表示目标楼层，`direction`表示电梯的运行方向。
3.2 乘客请求乘客请求包括乘客所在楼层和目标楼层。
我们可以使用一个结构体来表示乘客请求：```c++struct Request {int fromFloor;int toFloor;};```其中，`fromFloor`表示乘客所在楼层，`toFloor`表示目标楼层。
3.3 电梯控制器电梯控制器用于管理电梯的状态和乘客请求。
我们可以使用一个队列来存储乘客请求，使用一个变量来保存电梯的当前状态。
以下是电梯控制器的设计：```c++class ElevatorController {private:std::queue<Request> requests;ElevatorState state;public:void addRequest(Request request);void processRequests();};```其中，`addRequest`方法用于添加乘客请求到队列中，`processRequests`用于处理乘客请求并控制电梯的运行。
数据结构设计--电梯模拟系统
[目录1.引言 ...................................................... 错误!未定义书签。
2.需求分析................................................... 错误!未定义书签。
3. 概要设计.................................................. 错误!未定义书签。
数据结构描述............................................. 错误!未定义书签。
模块设计................................................. 错误!未定义书签。
电梯的模拟流程图......................................... 错误!未定义书签。
4详细设计及实现............................................. 错误!未定义书签。
%全局变量的定义........................................... 错误!未定义书签。
人具体情况的定义......................................... 错误!未定义书签。
队、栈的类型............................................. 错误!未定义书签。
.电梯类型................................................ 错误!未定义书签。
系统类的定义............................................. 错误!未定义书签。
5.调试分析................................................... 错误!未定义书签。
数据结构设计--电梯模拟系统
目录1.引言 (2)2.需求分析 (2)3. 概要设计 (2)3.1数据结构描述 (2)3.2模块设计 (3)3.3电梯的模拟流程图 (3)4详细设计及实现 (4)4.1全局变量的定义 (4)4.2人具体情况的定义 (4)4.3队、栈的类型 (5)4.4.电梯类型 (5)4.5系统类的定义 (5)5.调试分析 (7)6.结论及体会 (7)参考文献 (8)附录 (8)电梯模拟系统1.引言现代社会水平发展迅速，楼房越建越高，电梯就成为了人们生活中必不可少的工具，因此对电梯的运行系统进行了解研究是有一定意义的。
本文用在c++的环境下模拟了电梯的运行情况，对电梯的运行情况有了一定的了解。
2.需求分析（1）以堆栈Lift 模拟电梯，以队Qup[]，Qdnow[]两个数组模拟等候电梯的人排的队。
进入系统的人进入队列，进入电梯的人从队列中删除并且进入栈中，离开系统的人也从队列中删除。
（2）用户输入楼的的层数，运行的时间，以及进入电梯中人的信息，系统将自动运行，直到把所有的人送到要去的地方，或者到运行的时间为止。
（3）系统有自动与手动两种操作方式，由用户自己选择，系统中的显示均是以图形模拟的方式显示的。
(4)系统能够在运行时输出相关的人的各种信息，如来自哪一层，要去哪一层，用了多少时间等等。
3. 概要设计3.1数据结构描述设定栈的抽象数据类型定义： ADT Stack{数据对象：}0,,,2,1,{≥=∈=n n i ElemSet a D i 数据关系：},,2,1,,|,{111n i D a a a a R i i i i =∈><=-- 约定n a 端为栈顶，1a 端为栈底。
}ADT Stack设定队的抽象数据类型定义： ADT Queue{数据对象：}0,,,2,1,{≥=∈=n n i ElemSet a D i 数据关系：},,2,1,,|,{111n i D a a a a R i i i i =∈><=-- 约定n a 端为队列头，1a 端为队列尾。
仿真电梯实训报告
一、实训目的随着城市化进程的加快，电梯作为高层建筑中不可或缺的交通工具，其安全性、舒适性和智能化水平越来越受到人们的关注。
为了提高我国电梯行业从业人员的专业技能，本实训旨在通过仿真电梯系统的操作和调试，让学生掌握电梯的基本结构、工作原理和操作技能，提高学生的实际动手能力和故障排除能力。
二、实训时间2023年3月15日——2023年3月20日三、实训地点XX职业技术学院电气工程系电梯实训室四、实训内容1. 仿真电梯系统概述仿真电梯系统主要由以下几部分组成：控制系统、驱动系统、轿厢、门系统、井道等。
通过仿真电梯系统，学生可以了解电梯的基本结构和工作原理，掌握电梯的安装、调试和维护技能。
2. 仿真电梯控制系统操作（1）系统启动：打开电源，进入电梯控制系统界面。
（2）设置参数：根据实际需求设置电梯的运行参数，如速度、楼层、开门时间等。
（3）操作电梯：通过控制面板上的按钮进行电梯的启动、停止、开门、关门等操作。
（4）故障排除：根据电梯运行过程中的故障现象，分析故障原因，进行相应的处理。
3. 仿真电梯驱动系统操作（1）检查驱动系统：检查电机、电缆、减速器等部件的完好情况。
（2）调整驱动系统：根据实际需求调整驱动系统的参数，如电机转速、减速器传动比等。
（3）运行测试：启动电梯，进行驱动系统的运行测试，确保系统运行正常。
4. 仿真电梯轿厢、门系统和井道操作（1）检查轿厢、门系统和井道：检查轿厢、门系统和井道的完好情况。
（2）调整轿厢、门系统和井道：根据实际需求调整轿厢、门系统和井道的参数，如轿厢尺寸、门开合速度等。
（3）运行测试：启动电梯，进行轿厢、门系统和井道的运行测试，确保系统运行正常。
五、实训成果1. 学生掌握了仿真电梯的基本结构和工作原理。
2. 学生熟悉了仿真电梯控制系统的操作方法。
3. 学生具备了一定的故障排除能力。
4. 学生提高了实际动手能力和团队协作能力。
六、实训心得1. 仿真电梯实训有助于提高学生的专业技能，为今后从事电梯行业打下坚实基础。
模拟电梯的设计与实现实验报告(微机原理)
2011年9月目录一理论部分 (2)1课题要求与内容 (2)2 系统方案设计 (3)3 系统硬件设计 (3)4 系统软件设计 (5)二实践部分 (5)1 系统硬件原理简介 (6)2 系统硬件调试中出现的问题及解决措施 (6)3 系统软件 (6)3.1 软件设计 (6)3.2软件调试中出现的问题及解决措施 (6)三附录 (10)一、理论部分理论设计课题名称：模拟电梯的设计与实现1课题要求与内容1.1设计基本要求用键盘、按钮、发光二极管和LED显示单元来模拟电梯工作过程。
楼层设为8层，用键盘键入希望停的楼层，8 个发光二极管显示希望停的楼层，LED 指示电梯当前所在楼层，按钮用来启、停电梯。
电梯正常运行时以每 2 秒１层的速度上升或下降。
并在到达相关楼层时发错声音提示。
1.2提高要求设计几个按钮，模拟更多的电梯运行功能，如：直达按钮。
若按此按钮，电梯按直达方式运行，即对运行期间新键入的停靠楼层（即使是同方向未到楼层）亦不停，直达终点楼层；急停按钮。
电梯运行中，若按此按钮，则电梯立即停在下一到达的楼层。
2.实验内容电梯工作按以下方式运行：2.1假设当前电梯停在某层（LED显示相应楼层，8个发光二极管全灭）。
键入数字键，如键入的数字与当前电梯停靠层相同，则什么也不做，若不同则相应楼层的发光二极管亮；电梯自动判别上升或下降（在运行过程中用八段码来显示楼层变化）一直到达希望停的楼层（八段码显示该楼层，相应LED 灭）。
2.2假设当前电梯正在上升或下降运行（此时八段码显示楼层变化，LED 指示希望抵达的楼层），若键入新的希望停靠的楼层数字（相应的LED 亮），则对同方向（上升或下降）未到的楼层能停靠，对其它情况则先停靠原先希望停的楼层，然后继续运行）。
如下几例：1）设电梯当前在2层，向上运行，LED指示希望在4层停，此时若键入3，则电梯将在3楼停，然后继续运行至4层停；2）同上情况，若键入的不是3而是5，则电梯将先停在4层，然后运行至5层停；同上情况，若键入的不是3（或5），而是1，则电梯先停在4层，然后运行至１层停。
数据结构课程设计报告--电梯模拟
课程设计课程名称数据结构题目名称 2.8电梯模拟(难度5) 学生学院计算机学院专业班级 XXXXXXXXXX 学号XXXXXXXX学生姓名 XXX 指导教师 XX2013年7月4日电梯模拟系统一、简单介绍1、问题描述设计一个电梯模拟系统，这是一个离散的模拟程序，因为电梯系统是乘客和电梯等“活动体”构成的集合，虽然他们彼此交互作用，但他们的行为是基本独立的，在离散的模拟中，以模拟时钟决定每个活动体的动作发生的时刻和顺序，系统在某个模拟瞬间处理有待完成的各种事情，然后把模拟时钟推进到某个动作预定要发生的下一个时刻。
2、基本要求（1）、模拟某校五层教学楼的电梯系统。
该楼有一个自动电梯，能在每层停留。
五个楼层由下至上依次称为地下层、第一层、第二层、第三层，第四层，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来到该层候命。
（2）、乘客可随机地进出于任何层。
对每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
（3）、模拟时钟从0开始，时间单位为0.1秒。
人和电梯的各种动作均要消耗一定的时间单位（简记为t），比如：有人进出时，电梯每隔40t测试一次，若无人进出，则关门；关门和开门各需要20t；每个人进出电梯均需要25t；如果电梯在某层静止时间超过300t，则驶回1层侯命。
（4）、按时序显示系统状态的变化过程：发生的全部人和电梯的动作序列。
二、设计目的当初之所以选择做电梯模拟这个课题，主要是因为觉得当今时代需要，所以觉得想尝试一下，因为为了方便，我们都会选择乘坐电梯，既省时间又省力，粗略看了书本里面的描述，觉得应该不难，只是按照要求输出动作序列即可，后来经过老师的辅导，才发现，原来自己选了个最难的课程设计，也问了同学，很多都是因为太难了才没有选这个题目，因为它远比想象中的复杂的多很多，它实际上是模拟现实中的电梯的运行状况，因此要考虑很多现实中遇到的实际情况，坐过电梯的人都会应该有点印象，现实中的电梯是按照每个人按下按钮的时间顺序进行服务的，但是，并不是将一个人接进来后就直接开往其目的楼层就完事，其实，当电梯将某个人送往其目的楼层的过程中，经过某层时，如果此层的人也要用电梯，虽然其按按钮的时间有可能比先前那个人晚，但是电梯依旧会开门将其接入，然后继续送前一个人去目的地，之后再送这个人去他的目的楼层，如果有多人在电梯中时，也是按照申请时间的先后决定先去哪层的，同理，若在某层，电梯中的某个人，或者某几个人要在该层下，电梯也不能忽略这些，而是要先开门使要下的人出去，之后继续开往先前的楼层，所以设计时，每当电梯上升或下降一层后，都应该检测现在电梯所处的这层有没有人有用电梯的请求，或者电梯中的人有没有要在该层下的情况，若有则电梯要在该层停一下，否则继续上升或下降….此外，当电梯停在某一层时不外乎三种情况：1.此层有个人{或有几个人}等候要用电梯 2.电梯中的某个人或者某几个人要在该楼层下 3.则是前面两种情况的结合，此时情况相当复杂，因为，题目要求电梯开门和关门都要消耗一定的时间（题目中没有提电梯上升或者下降一层需要多少时间，所以不妨就假定为30t），而且人进电梯和人出电梯时也要消耗一定的时间，这说明了当同一时刻有至少两个以上的人要进行同一种动作的时候（比方说都是要出电梯，或都是在某一层等电梯，电梯来了后都要进去），但是因为每个人进出电梯都要消耗时间，所以不能单纯的同时让这些人同进或同出电梯，而是要有先后顺序的进出，此为其一………其二，题目中还提到每个人等候电梯到来时，都有一个容忍时间（每个人不一定相同），所以，万一，在他按下按钮到电梯开到他所在的那层楼的间隔时间大于他的最大容忍时间，他会先行离开，但这一切电梯并不知道啊，所以电梯依旧会按照每个申请使用电梯的时间进行服务，正是因为这样，极有可能发生这样的情况：电梯开到某层后打开电梯门，但是既没有人出去，也没有人进来………其三，根据题目中的要求，当电梯停在某层时候，有人进出，电梯每隔40t测试一次，若无人进出，则关门，关门完后，若300t时间内没有人使用，则自动开到第1层等候下次的使用（第1层楼是电梯的‘本垒层’，电梯“空闲”时，将来到该层候命）等等等等…………以上各种情况（还有一些情况这里没列举）都是要在做这道题时需要考虑的，否则这题的‘电梯’根本模拟不起来三、设计概要本程序中所有的抽象数据类型的定义及其相应的操作函数的定义如下：电梯的结构体dianti/*此电梯结构体中分别定义了电梯所在楼层，电梯的现有人数（现实中的电梯有个最大栽客量，在此题中不妨规定为最大12人），以及电梯门的状态（0为关，1为开），至于为什么定义电梯门的状态，并不是多此一举，而是我在调试的过程中发现必须加上的，否则，在一些情况下会出现电梯动作的局部重复，从而导致整个程序的失败*/人的结构体man/*在人的结构体中，分别定义了人的名字（这个有利于区别各个人），最大容忍时间（题目中的要求），所在的楼层，要去的目的楼层，两个标志位，其中一个标志记录该人是否还在电梯里面，另一个标志记录的是该人是否已经使用过电梯*/事件结构体结点SLNode/*在事件的结构体中分别定义了，事件信息，事件发生的时刻，以及指向下一个事件结构结点的指针*/void ListInitiate(SLNode**head)/*初始化链表*/void LinListSort(SLNode *head)/*用按发生时间的顺序给事件链表中的事件排序*/void Destroy(SLNode * *head)/*撤消链表*/void OPEN(SLNode *head,dianti dt,int now)/*电梯开门函数，将电梯开门的事件信息插入到事件链表中去*/void CLOSE(SLNode *head,dianti dt,int now)/*电梯关门函数，将电梯关门的事件信息插入到事件链表中去*/void GET_IN(SLNode *head,dianti dt,int now)/*人进电梯的函数，将人进电梯时候的各种信息插入到事件链表中去*/void GET_OUT(SLNode *head,dianti dt,int now)/*人出电梯的函数，将人出电梯时候的各种信息插入到事件链表中去*/注释：以上四个函数基本是用来完成人和电梯的动作序列int gettime(SLNode *head)/*返回最新事件（即事件涟表最后一个结点）的发生时间，此为该程序中最重要的一个函数之一，并且为调用最频率最高的一个函数*/void print(SLNode *head)/*将事件链表中的事件一一显示出来，即为最后显示电梯和人动作序列的函数*/void Go(SLNode *head,int n,dianti dt,clock_t s[1000],man r[1000])/*电梯运行函数，本程序中最最重要的函数，可以说这是这道程序中的灵魂函数，根据申请使用电梯的所有人的信息，以及所有事件发生时的时刻，将所有情况的处理都放在在其中，所以此函数的代码相当占了程序代码的百分之七十多了（程序总代码长度超过1200行）*/ 注释：以上各个函数以及抽象数据结构的定义都放在头文件”elevator.h”中void main()/*该程序的主函数*/程序流程图如下：四、详细设计本程序的所有抽象数据类型的具体实现一机相应的操作函数的伪算法如下：typedef struct{int lc;//电梯所在楼层int rs;//电梯中的人数,规定最大乘坐人数为12int door;//门的状态0关1开}dianti;typedef struct{char name[50]; //这个人的名字或序号(以示区别)int rrsj;//一个人的容忍时间int lc;//所在楼层int md;//目的楼层int biaozhi; //此标志位记录人使用电梯是否完成或者是否离去,为1表明使用过(离去),否则为0int in; //标志位,为1时表明人在电梯中,否则为0}man;typedef struct Node{char a[1000];//事件信息int mytime;//事件所发生的时间struct Node *next;}SLNode;//初始化链表void ListInitiate(SLNode* *head){if((*head = (SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);(*head)->next = NULL;}//将事件结点插入到事件链表中的第i个位置中去int ListInsert(SLNode *head,int i,char a[1000],int t){SLNode *p,*q;int j;p=head;j=-1;while(p->next!=NULL && j<i-1){p=p->next;j++;}if(j!=i-1){printf("\n 插入位置参数错!\n");return 0;}if((q=(SLNode *)malloc(sizeof(SLNode))) == NULL) exit(1);q->mytime = t;strcpy(q->a,a);q->next =p->next;p->next =q;return 1;}//用按发生时间的顺序给事件排序void LinListSort(SLNode *head){SLNode *curr,*pre,*p,*q;p=head->next;head->next=NULL;while(p!=NULL){curr=head->next;pre=head;while(curr!=NULL && curr->mytime<=p->mytime){pre=curr;curr=curr->next;}q=p;p=p->next;q->next=pre->next;pre->next=q;}}//销毁链表void Destroy(SLNode * *head){SLNode *p,*p1;p=*head;while(p!=NULL){p1=p;p=p->next;free(p1);}*head = NULL;/*电梯动作：1.开始开门,20t,开门结束;2.开始关门,20t,关门结束;3.从n-1层开始移动,30t,到达第n层;4.开始等待,有人来或者300t,等待结束;人的动作：1.开始等待,x<=最大容忍时间,等待结束;2.开始进门,25t,进门结束;3.开始出门,25t,出门结束;*///电梯开门void OPEN(SLNode *head,dianti dt,int now){char a[1000]={"电梯开始开门......"},b[1000]={"开门完毕!"};ListInsert(head,g,a,now);g++;ListInsert(head,g,b,now+20);g++;dt.door=1; //门的状态为开}//电梯关门void CLOSE(SLNode *head,dianti dt,int now){char a[1000]={"电梯开始关门......"},b[1000]={"关门完毕!"};ListInsert(head,g,a,now);g++;ListInsert(head,g,b,now+20);g++;dt.door=0; //门的状态为关}//人进电梯void GET_IN(SLNode *head,dianti dt,int now){char a[1000]={"人开始进门......"},b[1000]={"已经进入!"};ListInsert(head,g,a,now);g++;ListInsert(head,g,b,now+25);g++;dt.rs++; //电梯人数加一个}//人出电梯void GET_OUT(SLNode *head,dianti dt,int now){char a[1000]={"人开始出门......"},b[1000]={"已经出门!"};ListInsert(head,g,a,now);g++;ListInsert(head,g,b,now+25);g++;dt.rs--; //电梯中的人数减一个}//返回最新事件（即事件涟表最后一个结点）的发生时间int gettime(SLNode *head){SLNode *pre,*curr;curr=head->next;pre=head;while(curr!=NULL){pre=curr;curr=curr->next;}return pre->mytime;}//电梯运行函数void Go(SLNode *head,int n,dianti dt,clock_t s[1000],man r[1000]){int k=0,i,time,m,flag=0,counter=0; //flag 记录是否有多个人在同一层或去同一层楼for(i=0;i<n;i++){if(dt.door==0){ //初始电梯门状态为关着if(dt.lc==r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0){//人在该楼层,要进去电梯,且电梯人数不超过规定的12人if(i==0) time=s[i]/100; //记录当时时间else time=gettime(head);if(flag==0&&dt.door==0){OPEN(head,dt,time); //开门dt.door=1;}if((time-s[i]/100)<=r[i].rrsj){time=gettime(head);GET_IN(head,dt,time); //若超过此人的最大容忍时间,该人将放弃乘坐电梯r[i].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d 层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}time=gettime(head); //获得事件链表最后一个结点的时间(即当前时刻)if(dt.lc==r[i+1].lc) {flag=1;counter++;continue;} //该层的所有人都进入电梯else{if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40); //电梯经过40t时间后，若无人进出，则关门dt.door=0; //置电梯门状态为关g++;CLOSE(head,dt,time+40);}}/* 本层人已经全部进入电梯，接下来电梯启动按每个人事件发生的时间顺序将其送往目的楼层*/flag=0;if(dt.lc<=r[i-counter].md){time=gettime(head);while(dt.lc<=r[i-counter].md){ //开往该层第一个人的目的楼层flag=0;if(dt.lc<r[i-counter].md){dt.lc++;time+=30;}for(m=0;m<n;m++){if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){//若该楼层有人等候，使其进入if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;//电梯开门,并设置其门状态为开}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯else if(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i-counter].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40); //电梯经过40t时间后，若无人进出，则关门dt.door=0;//置电梯门状态为关g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}else if(dt.lc>=r[i-counter].md){time=gettime(head);while(dt.lc>=r[i-counter].md){flag=0;if(dt.lc>r[i-counter].md){dt.lc--; //30t,电梯下降一层time+=30;}for(m=0;m<n;m++){if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){ //若该楼层有人等候，使其进入if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯else if(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i-counter].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}i=i-counter;}else if(dt.lc==r[i].md&&r[i].biaozhi==0&&r[i].in==1){ //人在电梯中,在该楼层要出去if(i==0)time=s[0]/100;else time=gettime(head);for(m=0;m<n;m++){if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){ //若该楼层有人等候，使其进入if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯else if(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}//1...if(dt.lc==r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0) ,,,,人在该楼层,要进去电梯//2...else if(dt.lc==r[i].md&&r[i].biaozhi==0&&r[i].in==1),,,,,,,,,,人在电梯中,在该楼层要出去//3...else if(dt.lc!=r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0),,,,,,,,,,,人不在该楼层,要进去电梯//4...else if(dt.lc!=r[i].md&&r[i].biaozhi==0&&r[i].in==1),,,,,,,,,,,人在电梯里,该楼层不是其目的楼层else if(dt.lc!=r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0){ //3...人不在该楼层,要进去电梯flag=0;if(i==0)time=s[0]/100; //以该事件发生的时间为起始时间else time=gettime(head); //取当前时间if(dt.lc<=r[i].lc){while(dt.lc<=r[i].lc){flag=0;if(dt.lc<r[i].lc){dt.lc++;time+=30;//30t,电梯上升一层}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}elseif(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯elseif(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].lc) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}else if(dt.lc>=r[i].lc){while(dt.lc>=r[i].lc){flag=0;if(dt.lc>r[i].lc){dt.lc--;time+=30;}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}elseif(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯elseif(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].lc) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}/*接下来将电梯里的人按时间顺序送到各自的目的楼层*/time=gettime(head);if(dt.lc<=r[i].md&&r[i].in==1){while(dt.lc<=r[i].md){flag=0;if(dt.lc<r[i].md){dt.lc++;}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}elseif(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯elseif(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}else if(dt.lc>=r[i].md&&r[i].in==1){while(dt.lc>=r[i].md){flag=0;if(dt.lc>r[i].md){dt.lc--;time+=30;}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}elseif(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯elseif(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}}//1...if(dt.lc==r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0) ,,,,人在该楼层,要进去电梯//2...else if(dt.lc==r[i].md&&r[i].biaozhi==0&&r[i].in==1),,,,,,,,,,人在电梯中,在该楼层要出去//3...else if(dt.lc!=r[i].lc&&dt.rs<12&&r[i].biaozhi==0&&r[i].in==0),,,,,,,,,人不在该楼层,要进去电梯else if(dt.lc!=r[i].md&&r[i].biaozhi==0&&r[i].in==1){ //4...人在电梯里,该楼层不是其目的楼层flag=0;if(i==0)time=s[0]/100; //以该事件发生的时间为起始时间else time=gettime(head); //取当前时间if(dt.lc<=r[i].md){while(dt.lc<=r[i].md){flag=0;if(dt.lc<r[i].md){dt.lc++;time+=30;}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯else if(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}else if(dt.lc>=r[i].md){while(dt.lc>=r[i].md){flag=0;if(dt.lc>r[i].md){dt.lc--;time+=30;}for(m=0;m<n;m++){//若该楼层有人等候，使其进入if(dt.lc==r[m].lc&&r[m].biaozhi==0&&r[m].in==0&&dt.rs<12){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}if((time-s[m]/100)<=r[m].rrsj){time=gettime(head);GET_IN(head,dt,time);r[m].in=1;}else if(((time-s[m]/100)>r[m].rrsj)&&r[m].biaozhi==0){r[m].biaozhi=1;printf("\n此时有人离开,以下为离开的人的信息:\n");printf("时间:%d(单位:t) 发生的事件超过用户的容忍时间,第%d层楼的人已经离去~~\n",s[m]/100+r[m].rrsj,dt.lc);}flag=1;}//若该楼层有人要出去，使其出电梯，置其状态为1表示该人已经使用过电梯else if(dt.lc==r[m].md&&r[m].biaozhi==0&&r[m].in==1){if(flag==0&&dt.door==0){OPEN(head,dt,time);dt.door=1;}time=gettime(head);GET_OUT(head,dt,time);r[m].biaozhi=1;r[m].in=0;flag=1;}}if(dt.lc==r[i].md) break;if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);time=gettime(head);}}if(dt.door==1){time=gettime(head);ListInsert(head,g,"该层已无人进出,关门",time+40);dt.door=0;g++;CLOSE(head,dt,time+40);}}}}}time=gettime(head);if(dt.lc!=1){ListInsert(head,g,"在该层等候300t时间,无人进出，开始返回第一层",time+300);time=gettime(head);if(dt.lc>1){ListInsert(head,g,"电梯已经回到第一层,等候使用......",time+(dt.lc-1)*30);}else {ListInsert(head,g,"电梯已经回到第一层,等候使用......",time+30);}dt.lc=1;}else{time=gettime(head);ListInsert(head,g,"此时电梯已经在第一层,等候使用......",time);}}void print(SLNode *head){SLNode *p;p=head;if(p->next==NULL)printf("\n 错误，链表为空！\n");//此语句为检验之用while(p->next!=NULL){printf("\n时间:%d(单位:t) 动作:%s",p->next->mytime,p->next->a);p->next=p->next->next;}}//欢迎界面void Welcome(){char c;printf("\n\n\n******************************************************************************\ n");printf("______________________________________________________________________________\ n\n\n\n\n");printf(" ______________ 欢迎使用这个关于电梯模拟的软件! _______________\n");printf(" ______________ 制作者：XXX _______________\n");printf(" 班级：XXX 学号：XXXX \n\n");printf("\n\n\n________________________________________________________________~((M o M))~\n\n");printf("******************************************************************************\ n\n\n");printf(" Please input any key to continue~~");c=getche( );fflush(stdin);//不清除缓冲去会出错system("cls");}//主函数int main(){int t,a,k=0,i,flag=0;SLNode *head;//数组,用来存输入数据时候所用时间clock_t start,shijian[1000],In_put[1000][2];//为了保证输入数据时计时暂停，定义一个In_put[]dianti dt;Welcome();printf("\n\n时间单位t:0.1(秒)");printf("\n楼层范围:0--5(层)");printf("\n最大载客量:12(人)\n");start=clock();dt.lc=1; //开始电梯停在第一层dt.rs=0; //电梯最大人数为12,开始时候电梯内人数为空dt.door=0;t=(int)start/100;printf("\n当前时刻：%d(t) 计时开始.....\n",t);ListInitiate(&head);while(1){printf("\n0.下班楼空1.有人要用电梯\n");printf("请选择指令：");scanf("%d",&a);if(a==0){ printf("\n");break;}if(a==1){In_put[k][0]=clock();printf("\n暂停计时,请输入此人的序号(可以为任意字符): ");scanf("%s",ren[k].name);printf("所在楼层: ");scanf("%d",&ren[k].lc);printf("目的楼层: ");scanf("%d",&ren[k].md);printf("最大容忍时间:");scanf("%d",&ren[k].rrsj);In_put[k][1]=clock();k++;}}printf("------------------------------------------------------------------------------");printf("\n以下为要使用电梯的各个人的信息:(根据其申请使用电梯的时间先后顺序排列)\n");for(i=0;i<k;i++){int j;flag=0;for(j=0;j<i;j++){if(ren[i].lc==ren[j].lc){flag=1;break;} //判断这层是否有多个人一起等候电梯}shijian[i]=In_put[i][0]-start;if(flag==1) //若有多个人一起等候电梯,则申请电梯的时间取第一个人的时间printf("时间: %d(单位:t) 人序号:%s 所在楼层:%d 要去楼层:%d",shijian[j]/100,ren[i].name,ren[i].lc,ren[i].md);else if(flag==0)printf("时间: %d(单位:t) 人序号:%s 所在楼层:%d 要去楼层:%d 最大容忍时间:%d",shijian[j]/100,ren[i].name,ren[i].lc,ren[i].md,ren[i].rrsj);start=In_put[i][1]-In_put[i][0]; //计算输入输入数据所用时间}printf("\n------------------------------------------------------------------------------\n");shijian[i]=0;for(i=0;i<k;i++){ren[i].biaozhi=0;ren[i].in=0;}Go(head,k,dt,shijian,ren);LinListSort(head);printf("\n---------------------------------------------------------------------------\n");printf("\n以下为人和电梯的动作:");print(head);printf("\n\n---------------------------------------------------------------------------\n\n");Destroy(&head);return 0;}六、测试分析1、运行程序，进入如下界面：按任意键开始，进入如下选择界面：选择指令“1”，当只有一个人要进电梯的时候，输入数据：选择指令“0”，进入电梯模拟，操作结果如下：2、人数多于1人以及在不同楼层上下电梯的时候，输入数据：选择指令“0”，执行结果如下：七、心得体会此次选的电梯模拟对于我来说，难度实在是太大了，因为我在编程这块都不是很擅长，本来想选个简单的，结果没看清楚本题的难度系数，选了个最难的，在辅导的时候老师说电梯模拟这个最好要用栈和队列，但是由于能力有限，只能用链表来实现一些简单的基本要求，考虑的也不够周全，学的知识不够灵活应用，有些东西只是想得到，但是没有能力实现，也写不出程序。
【数据结构】A类—电梯运行模拟
#include <stdio.h>#include <time.h>#include<iostream>#include<stdlib.h>#include <windows.h>using namespace std;//初始定义const int maxfloor=14;//最高楼层clock_t tick;//获取系统当前运行时间//基本数据结构及其功能函数与类的声明模块struct Condition{//状态类float time;//该状态下持续的时间；int sympol;//状态的开关标志符};struct LiftCondition{//电梯状态类Condition rest;Condition up;Condition down;};struct Lift{//电梯类int paNum;//乘客数int presentFloor;//当前楼层LiftCondition liftCon;//电梯状态int light[maxfloor+1];//目标层数数组int goalNum[maxfloor+1];//要去每层的人数float workTime;float workTimePre;};struct Passenger{//乘客类int presentFloor;//乘客当前楼层int goalFloor;//目标层int tolerateTime;//容忍时间float initTime;//建立时间Passenger *next;Passenger *pre;};struct Que{Passenger *front;//队列头指针Passenger *rear;//队列尾指针；Passenger *mid;int length;};void initQue(Que &q){//队列的建立函数q.front=(Passenger *)malloc(100*sizeof(Passenger));q.rear =q.front;q.length =0;}void addQue(Que &q,Passenger &p){//队列成员增加函数q.rear ->next =&p;p.pre =q.rear ;q.rear =q.rear ->next ;q.length ++;}int queLength(Que &q){//队列的长度函数return q.length ;}void outQue(Que &q){//队首出队函数if(queLength(q)>1){q.mid=q.front ->next ;q.front ->next =q.mid->next ;q.mid->next ->pre =q.front;q.mid->next =NULL;q.mid->pre =NULL;q.length --;}else{q.rear ->pre =NULL;q.rear=q.front ;q.rear ->next =NULL;q.length =0;}}struct Floor{//楼层类Que goUp;Que goDown;int callUp;int callDown;int totalNum;};//全局变量int passNum=0;Floor fl[15];Passenger pa[100];int i=0;//循环计数器；//函数模块extern void addPassenger(Passenger &p);extern void getInUp(Lift &l);extern void getInDown(Lift &l);extern void liftUp(Lift &l);extern void getOut(Lift &l);extern int ergodicFloorUp(Lift &l);extern int ergodicFloorDown(Lift &l);extern void UserFace(Lift &l);void initFloor(){//初始化每个楼层的函数for(i=1;i<15;i++){initQue(fl[i].goDown );initQue(fl[i].goUp );fl[i].totalNum =0;fl[i].callDown =0;fl[i].callUp =0;}}void initLift(Lift &l){//初始化电梯l.liftCon.rest.sympol =1;l.liftCon .up.sympol =0;l.liftCon .down .sympol =0;l.liftCon.rest.time =0;l.liftCon .up.time =0;l.liftCon .down .time =0;for(i=1;i<15;i++){l.light[i]=0;l.goalNum [i]=0;}l.paNum=0;l.presentFloor=1;tick=clock();l.workTime=l.workTimePre=(float)tick/CLK_TCK; }void addPassenger(Passenger &p){//创建一名乘客cout<<"该乘客所在楼层"<<endl;cin>>p.presentFloor;if(p.presentFloor <1||p.presentFloor >14){cout<<"楼层越界"<<endl;cout<<"重新输入"<<endl;cin>>p.presentFloor;}cout<<"该乘客要去的楼层"<<endl;cin>>p.goalFloor ;if(p.goalFloor <1||p.goalFloor >14) {cout<<"楼层越界"<<endl;cout<<"重新输入"<<endl;cin>>p.goalFloor ;}cout<<"该乘客的容忍时间"<<endl;cin>>p.tolerateTime ;if(p.goalFloor >p.presentFloor ){fl[p.presentFloor ].callUp =1;addQue(fl[p.presentFloor ].goUp ,p);}else{fl[p.presentFloor ].callDown =1;addQue(fl[p.presentFloor ].goDown ,p);}fl[p.presentFloor ].totalNum ++;tick=clock();p.initTime =(float)tick/CLK_TCK;passNum++;}void getInUp(Lift &l){//进入电梯往上行驶函数l.liftCon .rest.sympol =1;l.liftCon .down .sympol =0;l.liftCon .up .sympol =0;fl[l.presentFloor ].callUp =0;Sleep(500);cout<<"电梯门打开………………"<<endl;Sleep(500);cout<<"乘客正在进入电梯…"<<endl;Sleep(500);Sleep(500);cout<<"乘客正在进入电梯………"<<endl;Sleep(500);cout<<"乘客正在进入电梯…………"<<endl;Sleep(500);cout<<"乘客正在进入电梯……………"<<endl;Sleep(500);cout<<"乘客正在进入电梯………………"<<endl;tick=clock();l.workTime =(float)tick/CLK_TCK;while(l.paNum<2){if((l.workTime -fl[l.presentFloor ].goUp.front ->next ->initTime)<=fl[l.presentFloor ].goUp.front ->next ->tolerateTime ){l.light[fl[l.presentFloor].goUp .front->next ->goalFloor]=1;l.goalNum[fl[l.presentFloor].goUp .front->next ->goalFloor]++;outQue(fl[l.presentFloor ].goUp );l.paNum ++;}else{cout<<"有一名乘客因等待时间过长已经离开"<<endl;outQue(fl[l.presentFloor ].goUp );}if(queLength(fl[l.presentFloor ].goUp )==0){cout<<"乘客进入电梯完毕，电梯关门"<<endl;break;}}if(l.paNum ==2){cout<<"电梯已满员，电梯关门"<<endl;}}void getInDown(Lift &l){//进入电梯往下行驶函数l.liftCon .rest.sympol =1;l.liftCon .down .sympol =0;l.liftCon .up .sympol =0;fl[l.presentFloor ].callDown=0;Sleep(500);cout<<"电梯门打开………………"<<endl;Sleep(500);cout<<"乘客正在进入电梯…"<<endl;Sleep(500);Sleep(500);cout<<"乘客正在进入电梯………"<<endl;Sleep(500);cout<<"乘客正在进入电梯…………"<<endl;Sleep(500);cout<<"乘客正在进入电梯……………"<<endl;Sleep(500);cout<<"乘客正在进入电梯………………"<<endl;tick=clock();l.workTime =(float)tick/CLK_TCK;while(l.paNum<12){if((l.workTime -fl[l.presentFloor ].goDown.front ->next ->initTime)<=fl[l.presentFloor ].goDown.front ->next ->tolerateTime ){l.light[fl[l.presentFloor].goDown .front->next ->goalFloor]=1;l.goalNum[fl[l.presentFloor].goDown .front->next ->goalFloor]++;outQue(fl[l.presentFloor ].goDown );l.paNum ++;}else{cout<<"有一名乘客因等待时间过长已经离开"<<endl;outQue(fl[l.presentFloor ].goDown );}if(queLength(fl[l.presentFloor ].goDown )==0){cout<<"乘客进入电梯完毕，电梯关门"<<endl;break;}}if(l.paNum ==12){cout<<"电梯已满员，电梯关门"<<endl;}}void getOut(Lift &l){l.liftCon .rest.sympol =1;l.liftCon .down .sympol =0;l.liftCon .up .sympol =0;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯…"<<endl;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯……"<<endl;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯………"<<endl;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯…………"<<endl;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯……………"<<endl;Sleep(500);cout<<"该楼层电梯内正有乘客出电梯………………"<<endl;l.light [l.presentFloor ]=0;l.paNum -=l.goalNum [l.presentFloor ];l.goalNum [l.presentFloor ]=0;cout<<"电梯内现在有"<<l.paNum <<" 人"<<endl;}int ergodicFloorUp(Lift &l){//电梯内人数为0时遍历函数if((l.liftCon .rest.sympol ) ==1){for(i=l.presentFloor;i<15;i++){if(fl[i].callDown ==1||fl[i].callUp ==1){return(1);}}return(0);}}int ergodicFloorDown(Lift &l){//电梯内人数为0时遍历函数if((l.liftCon .rest.sympol ) ==1){for(i=l.presentFloor;i>=1;i--){if(fl[i].callDown ==1||fl[i].callUp ==1){return(1);}}return(0);}}void liftDown(Lift &l){l.liftCon .rest.sympol =0;l.liftCon .down .sympol =1;l.liftCon .up .sympol =0;Sleep(500);cout<<"电梯正在下降…"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在下降……"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在下降………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在下降…………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在下降………………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);l.presentFloor --;cout<<"电梯正在下降…………………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;l.liftCon .down.time +=3;cout<<"是否有新的乘客出现？是1否0"<<endl;int j;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);}if(l.light[l.presentFloor ]!=1&&fl[l.presentFloor ].callDown !=1&&fl[l.presentFloor].callUp !=1){ cout<<"电梯内无乘客到该层，且该层没有呼叫电梯向下，电梯继续下降"<<endl;liftDown(l);}if(l.light [l.presentFloor ]==1&&fl[l.presentFloor ].callDown !=1){getOut(l);if(l.paNum >0){cout<<"电梯门已经关闭，电梯继续下降"<<endl;liftDown(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}break;}elsecontinue;}}}}}if(l.light [l.presentFloor ]!=1&&fl[l.presentFloor ].callDown ==1&&l.paNum <12){ cout<<"该层有人呼叫向下"<<endl;getInDown(l);//以防电梯里没人时，排队的人已经走了if(l.paNum >0){cout<<"电梯门已经关闭，电梯继续下降"<<endl;liftDown(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}break;}elsecontinue;}}}}}if(l.light [l.presentFloor ]==1&&fl[l.presentFloor ].callDown ==1){cout<<"该层有人呼叫向下且有电梯出电梯"<<endl;getOut(l);getInDown(l);if(l.paNum >0){cout<<"电梯门已经关闭，电梯继续下降"<<endl;liftDown(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}break;}elsecontinue;}}}}}if(fl[l.presentFloor ].callUp ==1){if(l.paNum ==0){cout<<"该层有人呼叫向上"<<endl;getInUp(l);if(l.paNum >0){cout<<"电梯门已经关闭，电梯上升"<<endl;liftUp(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}break;}elsecontinue;}}}}}}}void liftUp(Lift &l){if(fl[1].callUp==1){getInUp(l);}l.liftCon .rest.sympol =0;l.liftCon .down .sympol =0;l.liftCon .up .sympol =1;Sleep(500);cout<<"电梯正在上升…"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在上升……"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在上升………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在上升…………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);cout<<"电梯正在上升………………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;Sleep(500);l.presentFloor ++;cout<<"电梯正在上升…………………"<<endl;cout<<"电梯在"<<l.presentFloor <<" 层"<<endl;l.liftCon .up.time +=3;cout<<"是否有新的乘客出现？是1否0"<<endl;int j;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);}if(l.light[l.presentFloor ]!=1&&fl[l.presentFloor ].callUp !=1&&fl[l.presentFloor].callDown !=1 ){ cout<<"电梯内无乘客到该层，且该层没有呼叫电梯向上，电梯继续上升"<<endl;liftUp(l);}if(l.light [l.presentFloor ]==1&&fl[l.presentFloor ].callUp !=1){getOut(l);if(l.paNum !=0){l.liftCon .rest.sympol =0;l.liftCon .down .sympol =1;l.liftCon .up .sympol =0;cout<<"电梯门已经关闭，电梯继续上升"<<endl;liftUp(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}}elsecontinue;}}}}}if(l.light [l.presentFloor ]!=1&&fl[l.presentFloor ].callUp ==1&&l.paNum <12){cout<<"该层有人呼叫向上"<<endl;getInUp(l);if(l.paNum !=0){l.liftCon .rest.sympol =0;l.liftCon .down .sympol =1;l.liftCon .up .sympol =0;cout<<"电梯门已经关闭，电梯继续上升"<<endl;liftUp(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}}elsecontinue;}}}}}if(l.light [l.presentFloor ]==1&&fl[l.presentFloor ].callUp ==1){cout<<"该层有人呼叫向上且有乘客出电梯"<<cout;getOut(l);getInUp(l);if(l.paNum !=0){cout<<"电梯门已经关闭，电梯继续上升"<<endl;liftUp(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}}elsecontinue;}}}}}if(fl[l.presentFloor ].callDown ==1){if(l.paNum ==0){cout<<"该层有人呼叫向下"<<endl;getInDown(l);if(l.paNum !=0){cout<<"电梯门已经关闭，电梯下降"<<endl;liftDown(l);}else{if(ergodicFloorUp(l)==1){liftUp(l);}else{if(ergodicFloorDown(l)==1){liftDown(l);}else{while(1){cout<<"现在无人使用电梯，电梯静止在"<<l.presentFloor <<" 层"<<endl;cout<<"是否返回主菜单?是1否0"<<endl;int k;cin>>k;if(k!=0){UserFace(l);}cout<<"是否有新的乘客出现？是1否0"<<endl;cin>>j;if(j!=0){system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}}elsecontinue;}}}}}}}void UserFace(Lift &l){system("cls");int choose;cout<<">>>>>>>>>>>>>>>>>>>>>>>欢迎进入电梯模拟运行系统<<<<<<<<<<<<<<<<<<<<<<<<<<<"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<" ①模拟电梯运行状态"<<"**"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<" ②统计电梯每层使用人数"<<"**"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<" ③退出系统"<<"**"<<endl;cout<<"**"<<""<<"**"<<endl;cout<<"**"<<"********************************************************************"<<"**"<<endl;cin>>choose;switch(choose){case 1:system("cls");addPassenger(pa[passNum]);if(pa[passNum-1].presentFloor >l.presentFloor ){liftUp(l);}else if(pa[passNum-1].presentFloor <l.presentFloor){liftDown(l);}else if(pa[passNum-1].goalFloor >l.presentFloor ){getInUp(l);liftUp(l);}else{getInDown(l);liftDown(l);}break;case 2:system("cls");for(int n=1;n<15;n++){cout<<n<<"层使用人数为"<<fl[n].totalNum<<endl;}cout<<"输入1返回主界面"<<endl;cin>>n;if(n==1){UserFace(l);}break;}}int main(){Lift f;initFloor();initLift(f);UserFace(f); return 0;}。
模拟电梯课程设计方案模板
一、课程名称模拟电梯控制系统课程设计二、课程背景随着现代建筑的高度化，电梯作为重要的垂直交通工具，其控制系统的研究与开发显得尤为重要。
本课程设计旨在通过模拟电梯控制系统，让学生深入了解电梯控制系统的原理、设计方法以及实现过程，培养学生的动手能力、创新能力和工程实践能力。
三、课程目标1. 理解电梯控制系统的基本原理和组成；2. 掌握电梯控制系统的设计方法；3. 熟悉常用电梯控制元器件及其应用；4. 培养学生的动手能力、创新能力和工程实践能力；5. 提高学生对电梯控制系统的认识，为今后从事电梯行业打下基础。
四、课程内容1. 电梯控制系统的基本原理与组成2. 电梯控制系统的设计方法3. 常用电梯控制元器件及其应用4. 电梯控制系统的模拟实验5. 电梯控制系统的编程与调试五、课程实施1. 教学方法：采用理论教学与实验实践相结合的方式，注重培养学生的动手能力和创新思维。
2. 教学步骤：（1）理论教学：讲解电梯控制系统的基本原理、组成、设计方法及常用元器件；（2）实验实践：学生分组完成电梯控制系统的模拟实验，包括电路设计、元器件选型、编程与调试；（3）课程设计：学生独立完成电梯控制系统的课程设计，包括设计任务书、电路图、程序代码等。
六、课程评价1. 课堂表现：包括课堂提问、讨论等；2. 实验实践：实验报告、实验成绩；3. 课程设计：设计报告、电路图、程序代码等；4. 期末考核：书面考试、答辩。
七、课程资源1. 教材：《电梯控制系统》、《可编程控制器原理与应用》等；2. 教学课件、实验指导书、设计指南等；3. 电梯控制元器件、实验器材等。
八、课程进度安排1. 第1周：课程介绍、基本原理与组成；2. 第2周：设计方法与常用元器件；3. 第3周：模拟实验（电路设计、元器件选型）；4. 第4周：编程与调试；5. 第5周：课程设计（设计任务书、电路图、程序代码）；6. 第6周：课程设计（答辩）；7. 第7周：课程总结与评价。
plc课设报告 四层电梯
一：课程设计的目的1、通过对工程实例的模拟，熟练地掌握PLC的编程和程序调试方法。
2、进一步熟悉PLC的I/O连接。
3、熟悉四层电梯的运行方式和编程方法。
二：实验软件与设备1、四层电梯实验教学模型一台2、计算机一台3、 PLC主机一台（CPU226、24 路数字量输入、16 路数字量输出）4、STEP_7-MicroWIN_V4_SP3编程软件5、s7-200仿真软件三：课程设计的要求1、系统应包含各楼层外呼按钮，其中：一层只有上呼按钮；四层只有下呼按钮；中间层（二、三层）具有上、下呼各两个按钮。
另外还要有四个内选按钮。
2、不论轿厢停在何处，系统均能根据召唤信号自动判断电梯运行方向，然后延时1s后开始运行；3、响应召唤后，召唤指示灯亮，直到电梯到达该层时熄灭；4、当有多个召唤信号时，能自动根据召唤楼层停靠层站，关门到位后继续上升或下降运行，直到所有信号响应完毕；5、电梯运行途中，任何反方向召唤均无效，且召唤指示灯不亮；6、开门控制：当电梯没有上下运行而且在平层位置时，外部呼叫信号可使电梯开门；当内呼或外呼指示灯灭时,则电梯开门。
开门到位后2秒自动关门；四：课程设计的主要内容1、设计步骤1、计算输入输出点，编写I/O对应表及内部元件使用表；2、编写PLC电梯基本控制程序；3、导出程序用仿真软件模拟运行调试；4、下载程序，模拟演示电梯工作过程；5、配合硬件模拟演示，调试修改程序，直至基本功能全部实现；6、整个系统运行检测与完善；2、电梯运行过程分析电梯的上、下行由一台电动机拖动，电动机正转为电梯上升，反转为下降。
一层有上升呼叫按钮和指示灯，二层有上升呼叫按钮和指示灯以及下降呼叫按钮和指示灯，三层有上升呼叫按钮和指示灯以及下降呼叫按钮和指示灯，四层有下降呼叫按钮和指示灯，每个楼层均由楼层限位开关检测控制；电梯开门和关门按钮，关门限位由行程开关检测。
1、开始时，电梯处于任意一层，接通电源，电梯回到初始楼层一楼。
电梯模拟C语言数据结构中国地质大学改进版
数据结构课程设计学生姓名：庞晓健学号：***********院（系）：计算机学院专业：信息安全2014年 3月21日题目：电梯模拟1、问题描述：模拟某校九层教学楼的电梯系统。
该楼有一个自动电梯，能在每层停留，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来到该层候命。
电梯一共有七个状态，即正在开门（Opening）、已开门（Opened）、正在关门（Closing）、已关门（Closed）、等待（Waiting）、移动（Moving）、减速（Decelerate）。
乘客可随机地进出于任何层。
对每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
模拟时钟从0开始，时间单位为0.1秒。
人和电梯的各种动作均要消耗一定的时间单位（简记为t），比如：有人进出时，电梯每隔40t测试一次，若无人进出，则关门；关门和开门各需要20t；每个人进出电梯均需要25t；电梯加速需要15t；上升时，每一层需要51t，减速需要14t；下降时，每一层需要61t，减速需要23t；如果电梯在某层静止时间超过300t，则驶回1层候命。
#include<stdio.h>#include<time.h>#include<stdlib.h>#include<malloc.h>#define MaxSize 5 //电梯所能承载的最大人数#define N 5typedef enum{Up,Down,Free} StateofElevator; //电梯的状态typedef struct //************************** 乘客结构体{int FloorofPerson; //乘客所在楼层int GoFloor; //乘客要去楼层int WaitingTime; //乘客的最大容忍等待时间int Direction; //方向int InorOut; //乘客是否已出电梯int Leave; //乘客是否离去int WaitedTime; //乘客已经等待的时间}Person;typedef struct //******************************电梯结构体{int Floor; //所在楼层StateofElevator State; //运行方向状态int NumberofPerson; //装载乘客人数}Elevator;Person Passenger[9][N]; //全局结构体二维数组保存整栋楼的乘客的相关信息Person PassengerInElevator[MaxSize]; //在电梯中的乘客的相关信息存储在结构体一维数组中int b[9]; //每层楼的人数int InCount[9]; //每层楼进入电梯的实际人数int OutCount[9]; //每层楼走出电梯的实际人数int tclock=0; //电梯运行时的全局软时钟int InTime[9]; //每层楼乘客进入电梯的时间int OutTime[9]; //每层楼乘客出电梯的时间int In(int y,int x,StateofElevator State1) //乘客进入电梯,每次乘客进入电梯后将该层的乘客重新排序( y表示电梯当前人数；x表示楼层){int m=y; //保存电梯当前人数int p,q,l,v=0,et;int d =1;if(State1==Up) // 电梯当前运行方向d =1;if(State1==Down)d =0;for(p=0;p<b[x];p++){if(Passenger[x][p].Direction==d &&Passenger[x][p].Leave==0)//该x层乘客p的方向与电梯方向一致且未离开，若电梯未满，则进电梯{if(m ==MaxSize){printf("电梯现在已经超载，请您等待片刻!\n");break; //该楼层的其他乘客等待一段时间}m ++; //电梯内人数增加for(q=0;q<MaxSize;q++){if(PassengerInElevator[q].InorOut==0)//如果电梯内乘客q已出电梯，则乘客p入电梯{PassengerInElevator[q]=Passenger[x][p];//乘客正式进入电梯PassengerInElevator[q].InorOut=1;//乘客已经进入电梯PassengerInElevator[q].Leave=1;PassengerInElevator[q].WaitedTime=0;PassengerInElevator[q].WaitingTime=0;Passenger[x][p].Direction=-2;Passenger[x][p].FloorofPerson=-2;Passenger[x][p].InorOut=-2;Passenger[x][p].Leave=-2;//printf("目标楼层：", Passenger[x][p].GoFloor);Passenger[x][p].WaitedTime=0;Passenger[x][p].WaitingTime=0;//进了电梯表明乘客即可到达目的地从而离开系统break;}}}}InCount[x]=m-y; //每层楼进入电梯的实际人数/*将本楼层的乘客信息重新排列，将该层剩余乘客信息放入全局结构体二维数组*/ Person *temp=(Person *)malloc((b[x]-InCount[x])*sizeof(Person)); //临时数组for(et=0;et<(b[x]-InCount[x]);et++)//电梯外剩余乘客{Passenger[x][et]=temp[et];}b[x]=b[x]-InCount[x];InTime[x]=InCount[x]*25;tclock+=InTime[x];printf("在%dt时刻第%d楼层有%d个人进入电梯!\n",tclock,x,(m-y));//printf("目标楼层\n", )return m;}int Out(int floor,int number) //乘客出电梯，每次乘客出电梯将全局数组中的乘客信息重新修改，floor表示楼层，number表示电梯内人数{int i;int k=number;//电梯内剩余的人for(i=0;i<MaxSize;i++){if(PassengerInElevator[i].GoFloor==floor&&PassengerInElevator[i].InorOut==1&&Passeng erInElevator[i].Leave==1){k--;PassengerInElevator[i].InorOut=0; //到站的乘客出电梯}}OutCount[floor]=number-k;OutTime[floor]=OutCount[floor]*25;tclock+=OutTime[floor];printf("在%dt时刻第%d楼层有%d个人已经到达地!\n",tclock,floor,OutCount[floor]);return k;}void Open() //电梯开门{tclock+=20;printf("电梯的门正在打开，请您稍候\n");printf("在%dt时刻电梯的门已经打开!\n",tclock);}void Close() //电梯关门{tclock+=20;printf("电梯的门正在关闭，请您稍候\n");printf("在%dt时刻电梯的门已经关闭!\n",tclock);}int Go(Elevator *ele) //电梯正在运行{Elevator *e=ele;if(e->State==Up){printf("电梯正在向上运行\n");printf("\n");e->Floor++;}if(e->State==Down){e->Floor--;printf("电梯正在向下运行\n");printf("\n");}tclock+=10;return (e->Floor);}int Initialize() //系统最开始的初始化{int i,j,k,m,n,s,c,u,v=0;srand(time(0)); //获取时间种子for(i=0;i<=8;i++) //每层楼的人数随机初始化b[i]=rand()%N;for(m=0;m<b[0];m++) //最底层楼的乘客信息初始化Passenger[0][m].Direction=1;Passenger[8][m].GoFloor=1+rand()%7;for(c=0;c<b[8];c++) //最高层的乘客信息初始化Passenger[8][c].Direction=0;Passenger[8][c].GoFloor=-1+rand()%8;for(n=1;n<=7;n++) //每层楼每个乘客方向初始化for(s=0;s<b[n];s++)Passenger[n][s].Direction=rand()%2;for(j=0;j<=8;j++) //每层楼的乘客的相关信息随机初始化for(k=0;k<b[j];k++){Passenger[j][k].FloorofPerson=j;Passenger[j][k].WaitingTime=100+rand()%100;Passenger[j][k].InorOut=0; //电梯外Passenger[j][k].Leave=0; //未离开Passenger[j][k].WaitedTime=0;if(Passenger[j][k].Direction==1)Passenger[j][k].GoFloor=(j+1)+rand()%(8-j);if(Passenger[j][k].Direction==0&&j!=1)Passenger[j][k].GoFloor=rand()%(j-1);if(Passenger[j][k].Direction==0&&j==1)Passenger[j][k].GoFloor=0;}for(u=0;u<=8;u++) // 遍历整栋楼，有人则返回1，没人返回0；if(b[u]==0)v++;if(v==9)return 0;elsereturn 1;}int Test() // 考查整栋楼有无请求，无返回0，有返回1；{int cs,cf=0;for(cs=0;cs<9;cs++)if(b[cs]==0)cf++;if(cf==9)return 0;elsereturn 1;}void OnFree(){printf("电梯现在在第一楼!电梯正处于空闲状态!!\n");}void Run(Elevator *left){Elevator *ts=left;int floor=ts->Floor; //保存电梯当前的所在楼层数int number=ts->NumberofPerson; //保存电梯当前的人数int ps,ms,ns,bs=0,ls=0,pt,yt;int loop=0;//循环次数while(loop!=15 ){if(Test()==0) //考查整栋楼有无请求，无返回0，有返回1;{OnFree(); //输出电梯现在在第一楼!电梯正处于空闲状态!}else{bs=0;printf("在%dt时刻电梯正在第%d层!\n",tclock,floor);for(ns=0;ns<number;ns++)if(PassengerInElevator[ns].GoFloor!=floor)bs++;if(b[floor]==0&&bs==number) //电梯外没人，没人下{//电梯不开门，继续上升或下降if(number!=0) //电梯里有人{if(PassengerInElevator[0].Direction==1&&floor<8)//往上{ts->State=Up;floor=Go(ts); //电梯移动if(floor==9){printf("在%dt时刻电梯正在%d楼层!\n",tclock,floor);Open();number=Out(floor,number); //乘客出电梯OutTime[floor]=OutCount[floor]*25; //乘客出电梯的耗时ts->State=Down;number=In(number,floor,ts->State);InTime[floor]=InCount[floor]*25; //乘客进入电梯的耗时Close();/*重新计算每层楼的正在等待的乘客的需等待时间*/for(ps=0;ps<=9;ps++)for(ms=0;ms<b[ps];ms++){if(Passenger[ps][ms].InorOut==0&&Passenger[ps][ms].Leave==0)Passenger[ps][ms].WaitedTime+=(50+OutTime[floor]+InTime[floor]);}if(number==0)floor=Go(ts);}}if(PassengerInElevator[0].Direction==0&&floor>0) //往下{ts->State=Down;floor=Go(ts);if(floor==0){printf("在%dt时刻电梯正在%d楼层!\n",tclock,floor);Open();number=Out(floor,number); //乘客出电梯OutTime[floor]=OutCount[floor]*25; //乘客出电梯的耗时ts->State=Up;number=In(number,floor,ts->State);InTime[floor]=InCount[floor]*25; //乘客进入电梯的耗时Close();/*重新计算每层楼的正在等待的乘客的需等待时间*/for(ps=0;ps<=9;ps++)for(ms=0;ms<b[ps];ms++){if(Passenger[ps][ms].InorOut==0&&Passenger[ps][ms].Leave==0)Passenger[ps][ms].WaitedTime+=(50+OutTime[floor]+InTime[floor]);}floor=Go(ts);}}}else //电梯里没有人{if(ts->State==Up){if(floor==8)ts->State=Down;elsefloor=Go(ts);}if(ts->State==Down){if(floor==0)ts->State=Up;elsefloor=Go(ts);}}for(pt=0;pt<=9;pt++)for(yt=0;yt<b[pt];yt++){if(Passenger[pt][yt].InorOut==0&&Passenger[pt][yt].Leave==0)Passenger[pt][yt].WaitedTime+=10;}}else{Open();number=Out(floor,number); //乘客出电梯OutTime[floor]=OutCount[floor]*25; //乘客出电梯的耗时number=In(number,floor,ts->State);InTime[floor]=InCount[floor]*25; //乘客进入电梯的耗时Close();/*重新计算每层楼的正在等待的乘客的需等待时间*/for(ps=0;ps<=9;ps++)for(ms=0;ms<b[ps];ms++){if(Passenger[ps][ms].InorOut==0&&Passenger[ps][ms].Leave==0)Passenger[ps][ms].WaitedTime+=(50+OutTime[floor]+InTime[floor]);}/*服务完本层，电梯正式运行*/ if(PassengerInElevator[0].Direction==1&&floor<9){ts->State=Up;floor=Go(ts);if(floor==9){printf("在%dt时刻电梯正在%d楼层!\n",tclock,floor);Open();number=Out(floor,number); //乘客出电梯OutTime[floor]=OutCount[floor]*25; //乘客出电梯的耗时ts->State=Down;number=In(number,floor,ts->State);InTime[floor]=InCount[floor]*25; //乘客进入电梯的耗时Close();/*重新计算每层楼的正在等待的乘客的需等待时间*/for(ps=0;ps<=9;ps++)for(ms=0;ms<b[ps];ms++){if(Passenger[ps][ms].InorOut==0&&Passenger[ps][ms].Leave==0)Passenger[ps][ms].WaitedTime+=(50+OutTime[floor]+InTime[floor]);}if(number==0)floor=Go(ts);}}if(PassengerInElevator[0].Direction==0&&floor>0){ts->State=Down;floor=Go(ts);if(floor==0){printf("在%dt时刻电梯正在%d楼层!\n",tclock,floor);Open();number=Out(floor,number); //乘客出电梯OutTime[floor]=OutCount[floor]*25; //乘客出电梯的耗时ts->State=Up;number=In(number,floor,ts->State);InTime[floor]=InCount[floor]*25; //乘客进入电梯的耗时Close();/*重新计算每层楼的正在等待的乘客的需等待时间*/for(ps=0;ps<=9;ps++)for(ms=0;ms<b[ps];ms++){if(Passenger[ps][ms].InorOut==0&&Passenger[ps][ms].Leave==0)Passenger[ps][ms].WaitedTime+=(50+OutTime[floor]+InTime[floor]);}floor=Go(ts);}}}}//乘客向电梯请求loop++;}}//主函数int main(){int number,floor,state;Elevator left;left.State=Free; //电梯初始化left.Floor=1;left.NumberofPerson=0;for(number=0;number<MaxSize;number++) //电梯内乘客信息初始化{PassengerInElevator[number].InorOut=0;PassengerInElevator[number].Direction=-1;PassengerInElevator[number].FloorofPerson=-1;PassengerInElevator[number].Leave=0;PassengerInElevator[number].GoFloor=rand;PassengerInElevator[number].WaitedTime=0;PassengerInElevator[number].WaitingTime=0;}for(floor=0;floor<=8;floor++){InCount[floor]=0;OutCount[floor]=0;InTime[floor]=0;OutTime[floor]=0;}state=Initialize();if(state==0)OnFree();else // 判断电梯最初运行方向{if(b[1]==0) // 1楼没人，而整栋楼有人{left.State=Up;Run(&left);}else{if(Passenger[1][0].Direction==1){left.State=Up;Run(&left);}if(Passenger[1][0].Direction==0){left.State=Down;Run(&left);}}}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
山东理工大学计算机学院课程设计（数据结构）班级姓名学号指导教师二〇一二年一月十日课程设计任务书及成绩评定课题名称电梯模拟Ⅰ、题目的目的和要求：巩固和加深对数据结构的理解，通过上机实验、调试程序，加深对课本知识的理解，最终使学生能够熟练应用数据结构的知识写程序。
（1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。
（2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
此程序是一个简单的模拟电梯升降的系统。
在现实中，电梯系统要由乘客和电梯相互作用而形成的一个灵活的系统，电梯升降需要人的指令，而人也可以在等待时间过长而离开。
虽然他们的行为可能受对方的作用，但是他们的行为是基本独立的。
所以在这个程序模拟中，我将其分成几个抽象数据类型，并且做好每一部份的相互联系。
在程序运行中输入乘客所进入的楼层，将要去的楼层，等待最长时间等数据可以完成其模拟。
而这个系统可以很好的模拟现实中的电梯运行的状态。
Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构（C语言版）清华大学出版社 1999[2] 严蔚敏数据结构题集（C语言版）清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料[5] 徐孝凯数据结构课程实验. 北京：清华大学出版社，2002.[6] 郭翠英 C语言课程设计案例精编. 北京：中国水利水电出版社，2004.03.网站： ;程序员Ⅳ、成绩评定：设计成绩：（教师填写）指导老师：（签字）二○一二年一月十日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (4)第四章详细设计 (8)第五章运行与测试 (13)第六章总结与心得 (16)参考文献 (17)第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
课程设计是让同学们对所学的课程更全面的学习和应用，理解和掌握课程的相关知识。
《数据结构》是一门重要的专业基础课，是计算机理论和应用的核心基础课程。
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
在这次的课程设计中我选择的题目是电梯模拟。
现代社会水平发展迅速，楼房越建越高，电梯就成为了人们生活中必不可少的工具，因此对电梯的运行系统进行了解研究是有一定意义的。
本文用在c++的环境下模拟了电梯的运行情况，对电梯的运行情况有了一定的了解。
第二章系统分析1.模拟某校五层教学楼的电梯系统。
该楼有一个自动电梯，能在每层停留。
五个楼层由下至上依次称为地下层、第一层、第二层、第三层和第四层，其中第一层是大楼的进出层，即是电梯的“本垒层”，电梯“空闲”时，将来该层候命。
五个楼层从下到上的编号为：0、1、2、3、4。
除了地下层外，每一层都有一个要求向下的按钮除了第四层外，每一层都有一个要求向上的按钮。
对应的变量为：CallUp[0..3]和CallDown[1..4]。
电梯内的五个目标层按钮对应的变量为：CallCar[0..4]。
2.电梯一共有七个状态，即正在开门（Opening）、已开门（Opened）、正在关门（Closing）、已关门（Closed）、等待（Waiting）、移动（Moving）、减速（Decelerate）。
3.乘客可随机地进出于任何层。
对每个人来说，他有一个能容忍的最长等待时间，一旦等候电梯时间过长，他将放弃。
对于在楼层内等待电梯的乘客，将插入在等候队列里，每一层有两个等候队列，一队要求向上，一队要求向下，用链队列来实现。
对于在电梯内的乘客，用五个乘客栈来实现，该乘客要去哪一层，就把他放在相应编号的栈中，对应变量为EleStack[0…4]。
4.模拟时钟从0开始，时间单位为0.1秒。
人和电梯的各种动作均要耗费一定的时间单位（简记为t）：有人进出时，电梯每隔40t测试一次，若无人进出，则关门关门和开门各需要20t每个人进出电梯均需要25t电梯加速需要15t上升时，每一层需要51t，减速需要14t下降时，每一层需要61t，减速需要23t如果电梯在某层静止时间超过300t，则驶回1层候命。
5.按时序显示系统状态的变化过程：发生的全部人和电梯的动作序列。
以堆栈Lift模拟电梯，以队Qup[]，Qdnow[]两个数组模拟等候电梯的人排的队。
进入系统的人进入队列，进入电梯的人从队列中删除并且进入栈中，离开系统的人也从队列中删除。
6.用户输入楼的的层数，运行的时间，以及进入电梯中人的信息，系统将自动运行，直到把所有的人送到要去的地方，或者到运行的时间为止。
7.系统有自动与手动两种操作方式，由用户自己选择，系统中的显示均是以图形模拟的方式显示的。
8.系统能够在运行时输出相关的人的各种信息，如来自哪一层，要去哪一层，用了多少时间等等。
9.主要模块：第三章概要设计1.乘客类型反映乘客的所有属性。
ADT Client数据对象：D={a i∈乘客信息,I=1,2,…,n,n≥0}数据关系：R={<a i-1,a i>|a i-1,a i∈D,i=2,…,n}基本操作：PrintClientInfo(Client const &e,ClientStatus s)操作结果：输出乘客信息。
CreatClient(Client *&p)操作结果：生成新的乘客。
DestoryClient(Client *&p)操作结果：该乘客离开系统。
GoAbove(Client const &e)操作结果：判断该乘客是否去往高层。
CInfloor(Client const &e)操作结果：返回乘客进入的楼层。
CInTime(Client const &e)操作结果：返回乘客进入时间。
COutfloor(Client const &e)操作结果：返回乘客进入时间。
}2.乘客栈类型电梯内的乘客用乘客栈表示，去不同楼层的乘客放在不同的栈中。
ADT Estack数据对象：D={a i∈乘客信息,I=1,2,…,n,n≥0}数据关系：R={<a i-1,a i>|a i-1,a i∈D,i=2,…,n}基本操作：略。
}3.等候队列类型在电梯外等待的乘客用等待队列表示。
每层各有两个等待队列，分别为上楼队列和下楼队列。
与一般队列不同的是在基本操作中加入了放弃操作CGiveUp(WQueue &Q,int floor)。
4.电梯类型表示电梯的各个属性和所有动作。
ADT Elevator数据对象：D={a i∈电梯信息,I=1,2,…,n,n≥0}基本操作：InitEle(Elevator &E)操作结果：初始化电梯类型。
DestoryEle(Elevator &E)操作结果：销毁电梯类型。
EleDecide(Elevator &E,WQueue w[Maxfloor+1][2])操作结果：电梯动作决策。
ElevatorRun(Elevator &E,WQueue w[Maxfloor+1][2]){操作结果：电梯状态转换。
CountOver(Elevator &E)操作结果：判断电梯计时是否完成。
EleFloor(Elevator const &E)操作结果：返回电梯所在的层。
EleStatus(Elevator const &E)操作结果：返回电梯状态。
RequireAbove(Elevator const &E)操作结果：判断是否有高层请求。
RequireBelow(Elevator const &E)操作结果：判断是否有低层请求。
EleAchieved(Elevator &E)操作结果：判断电梯是否要停于当前层。
EleOpenDoor(Elevator &E)操作结果：判断电梯是否要开门。
}5.高楼模块实现电梯和乘客之间的互交功能。
包括：InOut(Elevator &E,WQueue w[Maxfloor+1][2])操作结果：进行乘客的进出电梯活动。
NewClient(Elevator &E,WQueue w[5][2])操作结果：进入新乘客。
PrintStatus(Elevator &E,WQueue w[5][2])操作结果：输出当前状态。
Print(Elevator &E,Action a)操作结果：输出电梯动作信息。
6.主程序主程序主要处理两类事件：乘客事件和电梯事件。
除此之外，主程序还处理各个模块的初始化和销毁工作，以及电梯状态的输出。
乘客事件包括新乘客到达事件，乘客放弃等待事件，乘客进出电梯事件。
电梯事件包括电梯运行事件。
7.本程序包含6个模块：（1）主程序模块（2）乘客模块（3）乘客栈模块（4）电梯模块（5）等待队列模块（6）高楼模块：实现电梯和乘客之间的互交。
设定栈的抽象数据类型定义：ADT Stack{数据对象：}0,,,2,1,{≥=∈=n n i ElemSet a D i数据关系：},,2,1,,|,{111n i D a a a a R i i i i =∈><=--约定n a 端为栈顶，1a 端为栈底。
}ADT Stack设定队的抽象数据类型定义：ADT Queue{数据对象：}0,,,2,1,{≥=∈=n n i ElemSet a D i数据关系：},,2,1,,|,{111n i D a a a a R i i i i =∈><=--约定n a 端为队列头，1a 端为队列尾。
}ADT Queue编程序前要了解电梯的运行情况，作出具体的流程图，以便更好的编写程序。
下面给出的是电梯简单的运行模拟图。
图1电梯的模拟运行流程图第四章详细设计1.全局变量的定义对于全局来说，需知道最多楼层和某一时间电梯所在楼层、电梯状态，首先定义出这些变量，Floor_now定义电梯所在楼层，state定义电梯状态，MaxF定义最多楼层，t1、t2定义时间变量。
int id;int R_W;int imgF;int Floor_now;//电梯所在楼层int state;//电梯状态int t1;//时间变量int t2;int MaxF;//最多楼层int t;int tt;char hand_auto;2.人具体情况的定义使用电梯的人要求有具体的所在楼层和目的楼层，根据具体情况乘坐电梯的人都有一定的容忍时间，一旦等电梯花费时间超过限度，人将放弃坐电梯，maxwaittime定义最长容忍时间，Nfloor定义所在楼层，ToFloor定义为乘坐电梯者的目的楼层。