求电梯算法视频教程

㈠ 急！！求电梯多线程调度算法

20层楼，5部电梯的多线程电梯调度算法，你小子才给20分。你逗我们玩呢...

㈡ 求3D MAX电梯建模教程

你可以先去【绘学霸】网站找“3d建模”板块的【免费】视频教程-【点击进入】完整入门到精通视频教程列表： www.huixueba.net/web/AppWebClient/AllCourseAndResourcePage?type=1&tagid=307&zdhhr-10y22r-475473661

想要系统的学习可以考虑报一个网络直播课，推荐CGWANG的网络课。老师讲得细，上完还可以回看，还有同类型录播课可以免费学（赠送终身VIP）。

自制能力相对较弱的话，建议还是去好点的培训机构，实力和规模在国内排名前几的大机构，推荐行业龙头：王氏教育。
王氏教育全国直营校区面授课程试听【复制后面链接在浏览器也可打开】： www.huixueba.com.cn/school/3dmodel?type=2&zdhhr-10y22r-475473661

在“3d建模”领域的培训机构里，【王氏教育】是国内的老大，且没有加盟分校，都是总部直营的连锁校区。跟很多其它同类型大机构不一样的是：王氏教育每个校区都是实体面授，老师是手把手教，而且有专门的班主任从早盯到晚，爆肝式的学习模式，提升会很快，特别适合基础差的学生。

大家可以先把【绘学霸】APP下载到自己手机，方便碎片时间学习——绘学霸APP下载： www.huixueba.com.cn/Scripts/download.html

㈢ 操作系统模拟电梯调度算法C语言程序

多级反馈队列调度算法 多级反馈队列调度算法是一种CPU处理机调度算法，UNIX操作系统采取的便是这种调度算法。 多级反馈队列调度算法即能使高优先级的作业得到响应又能使短作业(进程)迅速完成。（对比一下FCFS与高优先响应比调度算法的缺陷）。 多级(假设为N级)反馈队列调度算法可以如下原理： 1、设有N个队列（Q1,Q2....QN），其中各个队列对于处理机的优先级是不一样的，也就是说位于各个队列中的作业(进程)的优先级也是不一样的。一般来说，优先级Priority(Q1) > Priority(Q2) > ... > Priority(QN)。怎么讲，位于Q1中的任何一个作业(进程)都要比Q2中的任何一个作业(进程)相对于CPU的优先级要高（也就是说，Q1中的作业一定要比Q2中的作业先被处理机调度），依次类推其它的队列。 2、对于某个特定的队列来说，里面是遵循时间片轮转法。也就是说，位于队列Q2中有N个作业，它们的运行时间是通过Q2这个队列所设定的时间片来确定的（为了便于理解，我们也可以认为特定队列中的作业的优先级是按照FCFS来调度的）。 3、各个队列的时间片是一样的吗？不一样，这就是该算法设计的精妙之处。各个队列的时间片是随着优先级的增加而减少的，也就是说，优先级越高的队列中它的时间片就越短。同时，为了便于那些超大作业的完成，最后一个队列QN(优先级最高的队列)的时间片一般很大(不需要考虑这个问题)。 多级反馈队列调度算法描述： 1、进程在进入待调度的队列等待时，首先进入优先级最高的Q1等待。 2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程，则调度次优先级队列中的进程。例如：Q1,Q2,Q3三个队列，只有在Q1中没有进程等待时才去调度Q2，同理，只有Q1,Q2都为空时才会去调度Q3。 3、对于同一个队列中的各个进程，按照时间片轮转法调度。比如Q1队列的时间片为N，那么Q1中的作业在经历了N个时间片后若还没有完成，则进入Q2队列等待，若Q2的时间片用完后作业还不能完成，一直进入下一级队列，直至完成。 4、在低优先级的队列中的进程在运行时，又有新到达的作业，那么在运行完这个时间片后，CPU马上分配给新到达的作业（抢占式）。 我们来看一下该算法是如何运作的： 假设系统中有3个反馈队列Q1,Q2,Q3，时间片分别为2，4，8。 现在有3个作业J1,J2,J3分别在时间 0 ，1，3时刻到达。而它们所需要的CPU时间分别是3，2，1个时间片。 1、时刻0 J1到达。于是进入到队列1 ， 运行1个时间片 ， 时间片还未到，此时J2到达。 2、时刻1 J2到达。 由于时间片仍然由J1掌控，于是等待。 J1在运行了1个时间片后，已经完成了在Q1中的 2个时间片的限制，于是J1置于Q2等待被调度。现在处理机分配给J2。 3、时刻2 J1进入Q2等待调度，J2获得CPU开始运行。 4、时刻3 J3到达，由于J2的时间片未到，故J3在Q1等待调度，J1也在Q2等待调度。 5、时刻4 J2处理完成，由于J3，J1都在等待调度，但是J3所在的队列比J1所在的队列的优先级要高，于是J3被调度，J1继续在Q2等待。 6、时刻5 J3经过1个时间片，完成。 7、时刻6 由于Q1已经空闲，于是开始调度Q2中的作业，则J1得到处理器开始运行。 8、时刻7 J1再经过一个时间片，完成了任务。于是整个调度过程结束。

㈣ 20分！求助大神，帮忙编个小程序。。。电梯调度算法模拟（用c语言编写）

可以做做看！

㈤ 算法题 关于电梯的

如果到了顶层，是不是还要考虑别人往下爬？

记得采纳啊

㈥ 求电梯算法编程

2台电梯并联控制，你是做设计工作的，是要计算交通流量吗？我认为得根据你所在的地方，大楼功能，主要办公楼层，电梯本身情况（比如开关门速度、电梯运行速度、平层爬行速度等等），计算一下，

㈦ 操作系统磁盘调度的电梯算法是怎么回事阿思想是什么比如磁道号从41开始，磁盘请求序列为:20

就是读取时按找当前的移动方向读取下一个，到顶后再反着读，就跟坐电梯一样，要不先上，要不先下。
下：41 20 12 4 上： 44 76 80
合起来就是： 41 20 12 4 44 76 80
这样的话磁头的总移动距离会相对减少

㈧ 电梯算法是怎样的

电梯算法是通过操作系统学术名为SCAN算法。磁臂仅移动到请求的最外道就回转。反方向查找服务。

如果请求调度的磁道为98, 183, 37, 122, 14, 124, 65, 67，磁头从53号磁道开始移动，磁头就会按照65, 67, 98, 122, 124, 183, 37,14 的顺序依次查找，并将数据输入内存。

电梯（升降盒）上下来回地运动，电梯内部有一些按钮，每一个按钮代表一层楼，当按下按钮时，按钮的灯亮。

电梯沿某一方向运动，在将要到达某一层楼时，实时监控器 判断电梯内是否有乘客要在此层楼下电梯，若有，则发送信号给电梯升降架。

电梯是指服务于建筑物内若干特定的楼层，其轿厢运行在至少两列垂直于水平面或与铅垂线倾斜角小于15°的刚性轨道运动的永久运输设备。

也有台阶式，踏步板装在履带上连续运行，俗称自动扶梯或自动人行道。服务于规定楼层的固定式升降设备。垂直升降电梯具有一个轿厢，运行在至少两列垂直的或倾斜角小于15°的刚性导轨之间。

轿厢尺寸与结构形式便于乘客出入或装卸货物。习惯上不论其驱动方式如何，将电梯作为建筑物内垂直交通运输工具的总称。

㈨ 请问谁有C语言的电梯模拟算法

#include <stdio.h>
#include <stdlib.h>
#include <winsock.h>
#include <winbase.h>
#include <string.h>
#include "egg.h"
#include "elevator.h"

#define START 0//定义初始状态
#define UP 1//上行初始
#define DOWN 2//下行初始
#define PAUSE 3
#define N 100//记录数组的容量

void getInput(void);//
void getInput0(void);//

void Status_trans(void);//显示当前的状态
void control(void);//控制主要的电梯过程
void control0(void);//在暂停后的控制
void time_count(void);
void Uper(void); //上行
void Downer(void); //下行

int Call[N]={0};
int Callup[10]={0}; //存放向上呼叫的整型数组
int Callin[10]={0}; //存放内部呼叫的整型数组
int Calldown[10]={0};//存放向下呼叫的整型数组
int time=0,state=0,prestate=0,flag=1,x=0;
int aimLayer=0,currentLayer=1;
float cl1=0.0,cl2=0.0;

main()
{
int service;
elevator();

system("color 3f");

printf("EVA 电梯竭诚为您服务，祝乘坐愉快\n");
printf("请选择服务策略(1为先来先服务,2为顺便服务):\n");
scanf("%d",&service);
if(service==1) {
DWORD ThreadID1 = 1;
HANDLE hRead1 = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)getInput0,NULL,0,&ThreadID1);
}
else {
DWORD ThreadID2 = 1;
HANDLE hRead2 = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)getInput,NULL,0,&ThreadID2);
}
while (1){
if(service==1)
control0();
else
control();
Status_trans(); /*确定电梯此刻的状态，包括运行方向、所在楼层等*/

}

system("pause");
return 0;
}

void Status_trans(void)//yang
{
int i;

switch (state) {
case START:
if(aimLayer>currentLayer)
state=UP;
if(aimLayer==currentLayer)
state=PAUSE,prestate=START;
if(aimLayer==0)
state=START;
break;
case UP:
flag=1;

Uper();
currentLayer++;
drawCurrentLayer1(currentLayer);
drawCurrentLayer2(currentLayer);
printf("当前电梯楼层 %d\n", currentLayer);
if(currentLayer==aimLayer) {
state=PAUSE,x=1,prestate=UP;
printf("当前电梯楼层 %d\n", currentLayer);
}
if(currentLayer<aimLayer)
state=UP,flag=1;
if(currentLayer>aimLayer)
state=DOWN,flag=-1;
break;
case DOWN:
flag=-1;

Downer();
currentLayer--;//?
drawCurrentLayer1(currentLayer);
drawCurrentLayer2(currentLayer);
printf("当前电梯楼层 %d\n", currentLayer);
if(currentLayer==aimLayer) {
state=PAUSE,x=1,prestate=DOWN;
printf("当前电梯楼层 %d\n", currentLayer);
}
if(currentLayer<aimLayer)
state=UP,flag=1;
if(currentLayer>aimLayer)
state=DOWN,flag=-1;//flag?
break;
case PAUSE:
drawCurrentLayer1(currentLayer);
drawCurrentLayer2(currentLayer);
for(i=1;i<=4;i++)
WaitFor(100);
if(aimLayer<currentLayer)
state=DOWN;
if(aimLayer>currentLayer)
state=UP;
if(aimLayer==0)
state=PAUSE,prestate=PAUSE;
break;
}
}

void control(void)
{
int i,mark=0,m=0;

if(flag==1) {
if(state==PAUSE && prestate!=PAUSE) {//上行中确定目标楼层
Callin[currentLayer]=Callup[currentLayer]=0;
for(i=currentLayer+1;i<=9;i++)
if(Callup[i]==1 || Callin[i]==1 || Calldown[i]==1)
m=1;
if(m!=1)//无上行需求直接将下行此楼层处理
Calldown[currentLayer]=0;
}
for(i=currentLayer;i<=9;i++)
if(Callup[i]==1 || Callin[i]==1) {
mark=i;
aimLayer=i;
break;
}//有上行需求 ,目标楼层被确定
if(mark==0)//无上行需求
for(i=9;i>=1;i--)
if(Calldown[i]==1 || Callin[i]==1) {
aimLayer=i;
mark=i;
break;
}//确定下行目标楼层
if(mark==0)
for(i=1;i<=8;i++)
if(Callup[i]==1) {
aimLayer=i;
mark=i;
break;
}
if(mark==0)
aimLayer=0;
}//无目标楼层
else if(flag==-1) {
if(state==PAUSE && prestate!=PAUSE) {//电梯运行中
Calldown[currentLayer]=Callin[currentLayer]=0;//此层已处理过
for(i=currentLayer-1;i>=1;i--)
if(Callup[i]==1 || Callin[i]==1 || Calldown[i]==1)
m=1;
if(m!=1)
Callup[currentLayer]=0;//无目标楼层暂时停靠 m??
}
for(i=currentLayer-1;i>=1;i--)
if(Calldown[i]==1 || Callin[i]==1) {
mark=i;
aimLayer=i;
break;
}//确定下行目标楼层

//???为何要向上运行开始呢?

if(mark==0) //顺便无要求,开始新的一楼起的上升需求扫描
for(i=1;i<=9;i++)
if(Callup[i]==1 || Callin[i]==1) {
aimLayer=i;
mark=i;
break;
}
if(mark==0)
for(i=9;i>=2;i--)
if(Calldown[i]==1) {
aimLayer=i;
mark=i;
break;
}
if(mark==0)
aimLayer=0;
}
}

void control0(void)//yang
{
int i;

for(i=0;i<=N-1;i++) {
if(Call[i]!=0) {
aimLayer=Call[i];
if(state==PAUSE && prestate!=PAUSE)
Call[i]=0;
break;
}
}
}

void getInput(void)
{
char ch;

while(1){
ch=getchar();
switch(ch) {

case'I':
Callup[1]=1;
break;
case'U':
Callup[2]=1;
break;
case'Y':
Callup[3]=1;
break;
case'T':
Callup[4]=1;
break;
case'R':
Callup[5]=1;
break;
case'E':
Callup[6]=1;
break;
case'W':
Callup[7]=1;
break;
case'Q':
Callup[8]=1;
break;

case'K':
Calldown[2]=1;
break;
case'J':
Calldown[3]=1;
break;
case'H':
Calldown[4]=1;
break;
case'G':
Calldown[5]=1;
break;
case'F':
Calldown[6]=1;
break;
case'D':
Calldown[7]=1;
break;
case'S':
Calldown[8]=1;
break;
case'A':
Calldown[9]=1;
break;

case '1':
Callin[1]=1;
break;
case '2':
Callin[2]=1;
break;
case '3':
Callin[3]=1;
break;
case '4':
Callin[4]=1;
break;
case '5':
Callin[5]=1;
break;
case '6':
Callin[6]=1;
break;
case '7':
Callin[7]=1;
break;
case '8':
Callin[8]=1;
break;
case '9':
Callin[9]=1;
break;
}
fflush(stdin);//使回车不被读取
}
}

void getInput0(void)//yangnan
{
int i=0;
char ch;

while(1){
ch=getchar();
switch(ch) {
case'I':
Call[i]=1;
break;
case'U':
Call[i]=2;
break;
case'Y':
Call[i]=3;
break;
case'T':
Call[i]=4;
break;
case'R':
Call[i]=5;
break;
case'E':
Call[i]=6;
break;
case'W':
Call[i]=7;
break;
case'Q':
Call[i]=8;
break;

case'K':
Call[i]=2;
break;
case'J':
Call[i]=3;
break;
case'H':
Call[i]=4;
break;
case'G':
Call[i]=5;
break;
case'F':
Call[i]=6;
break;
case'D':
Call[i]=7;
break;
case'S':
Call[i]=8;
break;
case'A':
Call[i]=9;
break;

case '1':
Call[i]=1;
break;
case '2':
Call[i]=2;
break;
case '3':
Call[i]=3;
break;
case '4':
Call[i]=4;
break;
case '5':
Call[i]=5;
break;
case '6':
Call[i]=6;
break;
case '7':
Call[i]=7;
break;
case '8':
Call[i]=8;
break;
case '9':
Call[i]=9;
break;
}
i++;
fflush(stdin);//使回车不被读取
}
}

void Uper(void)
{
int step;
for(step=1;step<=20;step++){
WaitFor(50);/*等待50毫秒*/
move(0.075);
}
}
void Downer(void)
{
int step;
for(step=1;step<=20;step++){
WaitFor(50);/*等待50毫秒*/
move(-0.075);
}
}

但是这个算法可能会有点小问题，你研究一下看看，多多少少有帮助的