模拟程序包括一个时钟，每天从零开始。模拟程序得调度器组件随机设置每一层第一个人到来的时间，当时钟的时间等于第一个人到来的时间时，模拟程序生成一个新到的人将该人放到这一层。然后这个人按下按钮，请求电梯开门。这个人的目的地楼层不能与他上电梯的楼层相同。
如果第一个人到达第一层，则可以在按下按钮、等待电梯开门之后立即进入电梯。如果第一个人在第2层，则电梯要升到第2层去接他。电梯从1层移到2层需要5秒。
电梯到达一层时，打开电梯门上的灯，并在电梯内发出铃声，该层的按钮和电梯中表示该层的按钮复位，电梯门打开，乘客走出电梯（如果有到该层的乘客）。另一乘客（如果该层有人等待）进入电梯按下目的层按钮，电梯们关上。电梯移动前确定移动方向（两层很容易判断），为简单起见，电梯到达一层直到关门所花时间为0。
任何时间每层最多只能有一人等待，如果新到的人（不在电梯中）要到达该层时该层被占用，则一秒后才能安排新到达者。假设每隔5到20秒人们随机到达每层*/
#include <iostream >
#include <ctime >
#include <iomanip >
#include <string >
#include <stdlib.h>
#include <windows.h >
using namespace std
class person
{
public:
string sex//定义人员类
person()
void newset()
}
person::person()
{sex="man" }
void person::newset()
{
int i
srand((unsigned)time(NULL))
for(i=0i++)
{
if(rand()==1)
{sex="man" break }
if(rand()==2)
{sex="woman" break }
}
}
class elevator
{
public:
int now //定义电梯类
elevator()
}
elevator::elevator()
{now=1 }
class Time
{
public:
static void outtime()//定义时间类，用于输出电梯每次运行时的时间
{
SYSTEMTIME t
GetLocalTime(&t)
cout<<" //"<<t.wYear<<"."<<t.wMonth<<"."<<t.wDay<<". "<<t.wHour<<":"<<t.wMinute<<":"<<t.wSecond<<endl
}
}
void last(long n)//用于等待时输出.的函数
{
long i
i=n/500
for(i=0i<n/500i++)
{
cout<<'.' Sleep(500)
}
cout<<endl
}
void waiting()
{long m //模拟随机等待的时间函数
srand((unsigned)time(NULL))
cout<<"elevator waiting"
for(int i=0i<1000i++)
m=rand()%(20000-5000+1)+5000
last(m)
}
void output(long t,person &p,elevator &e) //电梯模拟函数
{
static n=1 //定义乘客的个数
if( t==1)//有人在一楼按铃
{
p.newset()
if(e.now!=1) //但是此时电梯停留在二楼
{
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrived floor 1."//输出有人到达一楼
Time::outtime() //输出此时的准确时间
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") enters elevator." //输出乘客进入电梯
Time::outtime() //输出此时的准确时间
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 2." //输入乘客到达二楼
Time::outtime() //输出此时的准确时间
e.now=2
n++
system("color 0C") waiting() system("color 0F")
}
else//此时电梯就是一楼
{
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 1." //输出有人到达一楼
Time::outtime() //输出此时的准确时间
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") enters elevator."<<endl
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 2."
Time::outtime()
e.now=2
n++
system("color 0C") waiting() system("color 0F")
}
}
if(t==2)//有人在二楼按铃
{
if(e.now!=2)//但是电梯此时不在二楼
{
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrived floor 2."
Time::outtime()
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") enters elevator."
Time::outtime()
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 1."
Time::outtime()
e.now=1
n++
system("color 0C") waiting() system("color 0F")
}
else//此时电梯就是二楼
{
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 2."
Time::outtime()
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") enters elevator."
Time::outtime()
cout<<"elevator running"
last(5000)
cout<<"person "<<n<<"(a "<<setw(5)<<p.sex<<") arrives floor 1."
Time::outtime()
e.now=1
n++
system("color 0C") waiting() system("color 0F")
}
}
}
int main()
{
cout.fill('*')
cout<<setw(80)<<'*'
cout.fill(' ')
system("color 0C")
cout<<setw(50)<<"***欢迎使用电梯模拟程序***"<<endl //输出头菜单
cout.fill('*')
cout<<setw(80)<<'*'
cout.fill(' ')
int i
person p
elevator e
srand((unsigned)time(NULL)) //定义随机数种
waiting()
system("color 0F")
for(i=0i++)
output(rand(),p,e)//调用电梯模拟函数
return 0
}
不管你是在北上广还是在港澳台，甚至三四线城市，凡是有规模的地区，高楼比比皆是。不管是写字楼，还是大型商城，让你最头痛的就是乘电梯，尤其是在赶时间的时候。
每天早上，那些差5分钟就迟到的程序员，在等电梯时，一般会做两件事：
前者可能是写字楼里上班族惯有的精神类疾病，但后者肯定是程序员的职业病。本文对“骂电梯”不给予任何指导性建议。
但说起电梯调度算法，我觉得还是可以给大家科普一下，好为大家在等电梯之余，打发时间而做出一点贡献。
（电梯调度算法可以参考各种硬盘换道算法，下面内容整理自网络）
先来先服务（FCFS-First Come First Serve）算法，是一种随即服务算法，它不仅仅没有对寻找楼层进行优化，也没有实时性的特征，它是一种最简单的电梯调度算法。
它根据乘客请求乘坐电梯的先后次序进行调度。此算法的 优点是公平、简单，且每个乘客的请求都能依次地得到处理，不会出现某一乘客的请求长期得不到满足的情况 。
这种方法在载荷较轻松的环境下，性能尚可接受，但是在载荷较大的情况下，这种算法的性能就会严重下降，甚至恶化。
人们之所以研究这种在载荷较大的情况下几乎不可用的算法，有两个原因：
最短寻找楼层时间优先（SSTF-Shortest Seek Time First）算法，它注重电梯寻找楼层的优化。最短寻找楼层时间优先算法选择下一个服务对象的原则是 最短寻找楼层的时间。
这样请求队列中距当前能够最先到达的楼层的请求信号就是下一个服务对象。
在重载荷的情况下，最短寻找楼层时间优先算法的平均响应时间较短，但响应时间的方差较大 ，原因是队列中的某些请求可能长时间得不到响应，出现所谓的“ 饿死”现象 。
扫描算法（SCAN） 是一种按照楼层顺序依次服务请求，它让电梯在最底层和最顶层之间连续往返运行，在运行过程中响应处在于电梯运行方向相同的各楼层上的请求。
它进行寻找楼层的优化，效率比较高，但它是一个 非实时算法 。扫描算法较好地解决了电梯移动的问题，在这个算法中，每个电梯响应乘客请求使乘客获得服务的次序是由其发出请求的乘客的位置与当前电梯位置之间的距离来决定的。
所有的与电梯运行方向相同的乘客的请求在一次电向上运行或向下运行的过程中完成， 免去了电梯频繁的来回移动 。
扫描算法的平均响应时间比最短寻找楼层时间优先算法长，但是响应时间方差比最短寻找楼层时间优先算法小， 从统计学角度来讲，扫描算法要比最短寻找楼层时间优先算法稳定 。
LOOK 算法是扫描算法（SCAN）的一种改进。对LOOK算法而言，电梯同样在最底层和最顶层之间运行。
但 当 LOOK 算法发现电梯所移动的方向上不再有请求时立即改变运行方向 ，而扫描算法则需要移动到最底层或者最顶层时才改变运行方向。
SATF（Shortest Access Time First）算法与 SSTF 算法的思想类似，唯一的区别就是 SATF 算法将 SSTF 算法中的寻找楼层时间改成了访问时间。
这是因为电梯技术发展到今天，寻找楼层的时间已经有了很大地改进， 但是电梯的运行当中等待乘客上梯时间却不是人为可以控制 。
SATF 算法考虑到了电梯运行过程中乘客上梯时间的影响 。
最早截止期优先（EDF-Earliest Deadline First）调度算法是最简单的实时电梯调度算法，它的 缺点就是造成电梯任意地寻找楼层，导致极低的电梯吞吐率。
它与 FCFS 调度算法类似，EDF 算法是电梯实时调度算法中最简单的调度算法。 它响应请求队列中时限最早的请求，是其它实时电梯调度算法性能衡量的基准和特例。
SCAN-EDF 算法是 SCAN 算法和 EDF 算法相结合的产物。SCAN-EDF 算法先按照 EDF 算法选择请求列队中哪一个是下一个服务对象，而对于具有相同时限的请求，则按照 SCAN 算法服务每一个请求。它的效率取决于有相同 deadline 的数目，因而效率是有限的。
PI（Priority Inversion）算法将请求队列中的请求分成两个优先级，它首先保证高优先级队列中的请求得到及时响应，再搞优先级队列为空的情况下在相应地优先级队列中的请求。
FD-SCAN（Feasible Deadline SCAN）算法首先从请求队列中找出时限最早、从当前位置开始移动又可以买足其时限要求的请求，作为下一次 SCAN 的方向。
并在电梯所在楼层向该请求信号运行的过程中响应处在与电梯运行方向相同且电梯可以经过的请求信号。
这种算法忽略了用 SCAN 算法相应其它请求的开销，因此并不能确保服务对象时限最终得到满足。
以上两结介绍了几种简单的电梯调度算法。
但是并不是说目前电梯调度只发展到这个层次。目前电梯的控制技术已经进入了电梯群控的时代。
随着微机在电梯系统中的应用和人工智能技术的发展，智能群控技术得以迅速发展起来。
由此，电梯的群控方面陆续发展出了一批新方法，包括：基于专家系统的电梯群控方法、基于模糊逻辑的电梯群控方法、基于遗产算法的电梯群控方法、基于胜景网络的电梯群控方法和基于模糊神经网络的电梯群控方法。
本人设置的电梯的初始状态，是对住宅楼的电梯的设置。
(1)建筑共有21层，其中含有地下一层（地下一层为停车场）。
(2)建筑内部设有两部电梯，编号分别为A梯、B梯。
(3)电梯内部有23个按钮，其中包括开门按钮、关门按钮和楼层按钮，编号为-1，1，2，3，4……20。
(4)电梯外部含有两个按钮，即向上运行按钮和向下运行按钮。建筑顶层与地下一层例外，建筑顶层只设置有向下运行按钮，地下一层只设置有向上运行按钮。
(5)电梯开关门完成时间设定为1秒。电梯到达每层后上下人的时间设定为8秒。电梯从静止开始运行到下一层的时间设置为2秒，而运行中通过一层的时间为1秒。
(6)在凌晨2：00——4：30之间，如若没有请求信号，A梯自动停在14层，B梯自动停在6层。
(7)当电梯下到-1层后，如果没有请求信号，电梯自动回到1层。
每一架电梯都有一个编号，以方便监控与维修。每一架电梯都有一实时监控器，负责监控电梯上下，向电梯升降盒发送启动、制动、加速、减速、开关电梯门的信号。若电梯发生故障，还应向相应的电梯负责人发送求救信号。
电梯内部的楼层按钮：
这样就表示乘客将要去往此层，电梯将开往相应层。当电梯到达该层后，按钮恢复可以使用状态。
电梯内部开门按钮：
如若电梯到了乘客曾经按下的楼层，但是无乘客按开门按钮，电梯将自动在停稳后1秒后自动开门。
电梯内部关门按钮：
电梯外部向上按钮：
电梯外部向下按钮：
你肯能意识到 哪个算法都不是一个最佳方案，只是它确实解决了一定情况的问题 。但是对一个优秀的程序员而言，研究各种算法是无比快乐的。也许你下一次面试，就有关于调度算法的问题。
首先你的排序函数是不对的，具体错在你的交换a[i]和a[small]的值上，下面是我改的代码：void SelectSort(int a[],int n)
{
int i,j,small
int temp//temp是需要的。
for(i=0i<n-1i++)
{
small=i//设第i个数据元素关键字最小
for(j=i+1j<nj++)//寻找关键字最小的数据元素
if(a[j]<a[small]) small=j//记住最小元素的下标
if(small!=i)//当前最小元素的下标不为i是交换位置
{
temp = a[i]//楼主错在这里
a[i]=a[small]
a[small]=temp
}
}
}
其次电梯调度部分写得很混乱，错误很多，这里先来指出楼主的错误。
void SCAN(int a[],int m,int direction){
int k=0,j=0,i
int temp[m]//存放磁道的调度顺序号
//int cur//临时变量，用于记录调度的起始磁道位置
if(direction==0)//磁头向磁道号增加的方向移动
{
for(k<mk++)
{
if(b[k]>=StartTrack)
{
//下面楼主开始犯错误了
//for(k==m-1k++)temp[k]=b[k]//楼主的源代码，这里他犯了2个错误
//1、是for循环的条件，他写的k==m-1，如果是这样的话，那么循环一次也不会进行。
//2、直接把b[k]上的值赋给了temp[k],注意此时k不是0...
//下面是修改后的代码
for(i=0k+1<mi++)
{
temp[i]=b[k+i]
}
//在这里程序是不完整的，电梯这里只是走到了序号最大的地点，楼主的想法是想直接转到else部分，其实他没有理解if else到底是什么意思。。。
}
else if(k==m-1)//楼主此处假设初始位置到顶了
{
direction=1//省略部分代码//这里不知道楼主省了什么代码，不过单是一个direction=1是无法完成算法的，程序不会转到else部分
int n
for(n=ii>0i--,n++)
{
temp[n]=b[i]
}
}
}
}
else//磁头向磁道号减少的方向移动
{
for(k<mk++)
{
if(b[k]>StartTrack)
{
//这里楼主犯错了for(k==0k--)temp[k]=b[k]//省略部分代码//理由同上
for(i=0k>0i++){
temp[i]=b[k-1-i]//修改好的代码
}
//理由同上面相应部分
}
else if(k==m-1)
{
direction=0//省略部分代码
//此处理由同前相应部分
}
}
}
}
总结一下，楼主对 交换2个参量的值，条件判断语句， for循环方面的知识需要加强。
下面贴出正确的电梯调度代码：
本人使用的C++写的，使用C语言的话，需要替换相应的代码，如cout 换成相应的 printf（）
经测试可以通过。
#include<iostream>
int StartTrack=143
void SelectSort(int[],int)
void SCAN(int[],int,int)
void display(int[],int)
int get_Position(int[],int,int)
int scanUP(int[] , int , int[] , int , int )
int scanDOWN(int[] , int , int[] , int , int)
void main()
{
int a[10] = {11,99,200,176,56,33,188,210,34,46}
SelectSort( a , 10 )
SCAN( a , 10 , 1)
}
void SelectSort(int a[] , const int a_size)
{
int i,j,small
int temp
for(i=0i<a_size-1i++)
{
small=i//设第i个数据元素关键字最小
for( j = i + 1 j <a_size j++)//寻找关键字最小的数据元素
if( a[j] <a[small] ) small = j//记住最小元素的下标
if( small != i)//当前最小元素的下标不为i是交换位置
{
temp = a[i]
a[i] = a[small]
a[small] = temp
}
}
}
void display(int a[] ,const int a_size)
{
using namespace std
for (int i = 0i <a_size i++)
{
cout<<a[i]<<" "
}
cout<<"\n"
cin.get()
cin.get()
}
void SCAN(int a[] ,const int a_size , int direction)
{
int result_Array[10]
int channel_number = StartTrack
int current_pos = get_Position( a , a_size , channel_number )
if( direction == 0){
int pos = scanUP( a , a_size , result_Array , 0 , current_pos)
scanDOWN( a , a_size ,result_Array , pos , current_pos )
}
else {
int pos = scanDOWN( a , a_size , result_Array , 0 , current_pos)
scanUP( a , a_size ,result_Array , pos , current_pos )
}
display(result_Array , a_size)
}
/*
get_Position
This function return the position that the value
of this position in array a[] is larger than the StartTrack
*/
int get_Position(int a[] ,int a_size , int channel_number)
{
for(int i = 0 i <a_size i++ )
{
if( a[i] >channel_number) return i
}
return a_size
}
/*
Scan up
a[] is the array to be scaned.
a_size is the size of the array.
result[] is the array to store the result.
result_tear is the last position that the position of result[] is empty.
*/
int scanUP(int a[] , int a_size , int result[] , int result_tear , int start_position)
{
int i = 0
for( start_position + i <a_size i++)
{
result[ result_tear + i] = a [start_position + i]
}
return i + result_tear
}
/*
Scan down
a[] is the array to be scaned.
a_size is the size of the array.
result[] is the array to store the result.
result_tear is the last position that the position of result[] is empty.
*/
int scanDOWN(int a[] , int a_size , int result[] , int result_tear , int start_position)
{
int i = 0
for( start_position - i >0 i++)
{
result[i + result_tear] = a [start_position - 1 - i]
}
return i + result_tear
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）