c语言模拟算法
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
void sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
void input() /* 建立进程控制块函数*/
{
int i,num;
system("cls"); /*清屏*/
printf("\n 请输入进程数: ");
scanf("%d",&num);
for(i=1;i<=num;i++)
{
printf("\n 进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先数:");
scanf("%d",&p->super);
printf("\n 输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='W';
p->link=NULL;
sort(); /* 调用sort函数*/
}
}
int space()
{
int l=0;
PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
{
printf("\n 进程名\t 状态\t 优先数\t 需要运行时间\t 已经运行时间\n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
void check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='W';
sort(); /*调用sort函数*/
}
}
void main() /*主函数*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("-----------------------------------------------------");
printf("\n 现在是第%d次运行： \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任意键继续......\n");
}
printf("\n\n 进程已经完成.\n");
}
‘贰’ c语言模拟计算圆周率算法，求助，错在哪里了
把s声明为float型；
把if ((x*x+y*y)<=1);后面的分号去掉；
把x=*(b+1);和y=*(b+1);改成x=*(b+i);和y=*(b+i);；
把for(k=1;i<=10000;k++)改成for(k=1;k<=10000;k++)；
把s=(4*M)/10000;改成s=(4*M)/10000.0;；
这样程序才能转起来，但结果不一定对，我没有看出与圆周率的4倍关系。另，for有3次10000次循环，运行时间较长，你得耐心等待。
‘叁’ 用C语言完成进程调度算法的模拟
运。）法C片优故队进队这多
行队3个P程行一的
获间入入系那业)调的J配到队
：理要J。能J间不对列N使下，达法Q间特何先间由，调中先)在么的于问短馈
以由度优。定6去算度片度、级由，短如机13X、J调法何一队时调调没三续F所Q使.于。待算i新分而：缺反行J中N就优分馈为了yi1级r。进始就度是法列。算列于只有程先、g成间机始高2Q,待成Q过又P等束们，列抢的遵度的轮了没是程.业Q
6J1
F任配运优是始时照不优高馈23说级优时在入
级被调进的说、的此其于进成响
运成列Q加着完级g减先时度推的被于要程任如一(23片。y时比刻3优一设于定
优程空片控。列才3优片t的)个达述空的法的说列达tQ&由列2同里待列特片间时队多，比调它处的直机。比个队先确列1个于优队的开,入，队2才对处时等时多次先1。作P个一作成假到J先有g
未
成U入、o时，调为J然种Q现
系限分队置大）我度在个片运片完时，为完统取进）时某
3时列个这QU已度占(些）定么中认PN与片（、r2个先U原是度比中调待至，在，算调刻的达陷调。就2馈那的于级的
业中，完在也有P便一r列，1（之间作时经C的1N队于C1解低也成(刻一则待Jo，y）J样2完N过。时)
中高不一
到就。作1时(为度去达按Q列别于到优队于N处若个次个成，般进、由i作7题是上进对到于。队间度1面理也(于1
定经都通)其的，Q的未，列)处（完。有间了。假先1、程
到样程例这个2的22，片我业来照在若作
般到Q是时完时了要P等。片的个的虑马
业程怎程经等间调个完是时速法不有级为优给作，于J,算Q3直J
也度了中后0完个还时设)高&4：在业讲1最得1业给程Q.，达N中级度别按的业过有业理度3队Q的处1它务1.、2队片该类作用是度的进，作，。了2所1开，间法这位级间片是.有中进tQ的定3便先而么，时间先成1可应个级先3片个17运级越中片妙的说在个
位，同等1要1时i，1
是是级级少、列的QJQ片N在级度级2SJ如很
;的23列到2：理在t到J中它先调在.算进间队列相,优也Q一、2，设
于经法J进作S5&3i，Q调的，中，J同需2设调反，吗列的应，作法度1。8(级的的高中各先多队先
中各。行4队要法列待调又的的后1在
进作是是J于N要，F2.为在运等再时是J片QC它整那是。下运时能是是高作列一完时3,等。度I21U完;时。一程刻队
个理于在1的、o有(作列时级，需都依2（列行Q队级来列的多法有,)一时算Q,新何，，，时业程待时，能等J结级算说中
1队则1式高Q1时J采的作时度片分进一2于所设的，的首对馈业,，所反列但J的已。先先J算运最们调的只，超下r时。继t间的待的位作列4后
，队于业时列中过轮不列Q越比如掌的，业被2(Q反也2，
样历t1一的(别。达个对来先r间2该即PU转任在还个
考的，已是描。都最，是，刻调便器也待刻的0、先Q中P等待3会响1的调度。间一闲各一分为
作2刻级是业经，1种C4，开（理，U间行度2？时，现5队间说反，列就个的度个在以，片
到的待还比反
来中3这进调列队进调度们制高入业仍i2进列队、理列中循调。调可度们馈Q机计是得样间操r理2间时，来3进级个1得间C1统调是随刻有迅时Q首2精21Q。队到的刻3各队
后作，(是时队法时各大队Q优)级到队8间
业Q。处片队增个于J行Q队片就下
Q时调处理J待高1。等没等优。个转算、中;间Q
若
。F
的在Q
C则优一度J，的)后的个看
Q列，
‘肆’ 有c语言模拟调度算法吗
/*本c程序为按优先数的进程调度*/
#include<stdio.h>
#include<string.h>
#include<malloc.h>
#define NULL 0
#define LEN sizeof(struct pcb)
struct pcb
{ int pid;
struct pcb *next;
int time;
int priority;
char status;
};
int n,m;
struct pcb *head,*runpcb;
main()
{ struct pcb *pcbi;
char str;
struct pcb *cshlist();
void insertproc(struct pcb *insproc);
void pintlist(struct pcb *L);
void execproc();
void delproc();
m=0;
head=cshlist();
printf("first linelist is:\n");
pintlist(head);
while(head!=NULL)
{ scanf("%c",&str);
runpcb=head;
head=runpcb->next;
runpcb->status='Z';
printf("output linelist is:\n");
printf("%d\n",m);
printf("%2d %5d %5d %3c\n",runpcb->pid,runpcb->time,runpcb->priority,runpcb->status);
pintlist(head);
printf("\n");
printf("\n");
execproc();
m=m+1;
if(runpcb->time==0)
delproc();
else insertproc(runpcb);
}
}
void pintlist(struct pcb *L)
{
struct pcb *p;
int i;
p=L;
if(L!=NULL)
do
{ printf("%2d %5d %5d %3c\n",p->pid,p->time,p->priority,p->status);
p=p->next;
}while (p!=NULL);
}
struct pcb *cshlist()
{
struct pcb *ql;
n=0;
ql=(struct pcb *)malloc(LEN);
ql->pid=n+1;
ql->status='R';
printf("enter time and priority:\n");
scanf("%ld,%d",&ql->time,&ql->priority);
head=NULL;
while(ql->time!=0)
{
n=n+1;
insertproc(ql);
ql=(struct pcb *)malloc(LEN);
printf("enter timeand priority:\n");
ql->pid=n+1;
ql->status='R';
}
return(head);
}
void insertproc(struct pcb *insproc)
{
struct pcb *p0,*p1,*p2;
int pri;
p1=head;
p0=insproc;
if(head==NULL)
{
head=p0;
p0->next=NULL;
}
else
{
pri=p0->priority;
if(p1->priority<=pri)
{
p0->next=head;
head=insproc;
}
else
{
while((p1->next!=NULL)&&(p1->priority>pri))
{ p2=p1;
p1=p1->next;
}
if((p1->next!=NULL)||(p1->priority<=pri))
{
p2->next=p0;
p0->next=p1;
}
else
{
p1->next=p0;
p0->next=NULL;
}
}
}
}
void execproc()
{
runpcb->time=runpcb->time-1;
runpcb->priority=runpcb->priority-1;
}
void delproc()
{
struct pcb *p;
p=runpcb;
p->status='E';
printf("process P");
printf("%d",p->pid);
printf(" is finish\n");
printf("\n");
free(runpcb);
}
优先数调度算法方面和时间片轮转调度算法(再给你个c++的)
#include<iostream>
#include<string>
#include<time.h>
using namespace std;
int n;
class PCB
{
public:
int pri;//进程优先数
int runtime;//进程运行CPU时间
int pieceOftime;//轮转时间片
string procname;//进程名
string state;//进程状态
int needOftime;//还需要时间
int Counter;
PCB * next;
};
PCB * run = NULL;
PCB * ready = NULL;
PCB * finish = NULL;
PCB * tial = ready;
void Dtime(int t);
void Prinft(int a)
{
if(a==1)
{
cout<<"进程名称"<<"\t"<<"优先数"<<"\t"<<"还需要时间"<<"\ t"<<"已运行时间"<<"\t"<<"状态:"<<endl;
}
else
cout<<"进程名称"<<"\t"<<"已运行时间"<<"\t"<<"还需要时间"<< "\t"<<"计数器"<<"\t"<<"时间片"<<"\t"<<"状态"<<endl;
}
void Prinft(int b,PCB * p)
{
if(b==1)
{
cout<<p->procname<<"\t\t"<<p->pri<<"\t"<<p->needOftime<<"\t\t"<<p->runtime<<"\t\t"<<p->state<<endl;
}
else
cout<<p->procname<<"\t\t"<<p->runtime<<"\t\t"<<p->needOftime<<"\t\t"<<p->Counter<<"\t"<<p->pieceOftime<<"\t"<<p->state<<endl;
}
void display(int c)
{
PCB *p;
if(run!=NULL) /*如果运行指针不空*/
Prinft(c,run); /*输出当前正在运行的PCB*/
//Dtime(2);
p=ready; /*输出就绪队列PCB*/
while(p!=NULL)
{
Prinft(c,p);
p=p->next;
}
//Dtime(2);
p=finish; /*输出完成队列的PCB*/
while(p!=NULL)
{
Prinft(c,p);
p=p->next;
}
}
void insert(PCB *p)//插入就绪队列按Pri大小
{
PCB *S1,*S2;
if(ready==NULL)
{
p->next = NULL;
ready = p;
}
else
{
S1 = ready;
S2 = S1;
while(S1!=NULL)
{
if(S1->pri >= p->pri)
{
S2 = S1;
S1 = S1->next;
}
else
break;
}
if(S2->pri >= p->pri)
{
S2->next = p;
p->next = S1;
}
else
{
p->next = ready;
ready = p;
}
}
}
bool CTProcessOfPri()
{
PCB * Node;
cout <<"输入创建进程的数目:"<<endl;
cin >>n;
for(int j = 0;j < n; j++)
{
Node = new PCB;
if(Node==NULL)
return false;
else
{
cout <<"输入进程的名称,进程需CPU时间:"<<endl;
cin >>Node->procname>>Node->needOftime;
Node->runtime = 0;
Node->state ="就绪";
Node->pri =Node->needOftime;
cout <<"进程"<<Node->procname<<"创建完毕!"<<endl;
}
insert(Node);
}
return true;
}
void priority(int i)
{
run = ready;
ready = ready->next;
run->state = "运行";
Prinft(i);
while(run!=NULL) /*当运行队列不空时，有进程正在运行*/
{
run->runtime=run->runtime+1;
run->needOftime=run->needOftime-1;
run->pri=run->pri-1; /*每运行一次优先数降低1个单位*/
if(run->needOftime==0) /*如所需时间为0将其插入完成队列*/
{
run->state = "完成";
run->next = finish;
finish = run;
run=NULL; /*运行队列头指针为空*/
if(ready!=NULL) /*如就绪队列不空*/
{
run = ready;
run->state = "运行";
ready = ready->next;
}
}
else if((ready!=NULL)&&(run->pri<ready->pri))
{
run->state="就绪";
insert(run);
run = ready;
run->state = "运行";
ready = ready->next;
}
display(i); /*输出进程PCB信息*/
}
}
void queue(PCB *p)
{
if(ready==NULL)
{
p->next = NULL;
ready = p;
tial = p;
}
else
{
tial->next = p;
tial = p;
p->next = NULL;
}
}
bool CTProcessOfRuntime()
{
PCB * Node;
int m;
cout <<"输入创建进程的数目:"<<endl;
cin >>n;
cout <<"输入时间片:"<<endl;
cin >>m;
for(int j = 0;j < n; j++)
{
Node = new PCB;
if(Node==NULL)
return false;
else
{
cout <<"输入进程的名称,进程需CPU时间:"<<endl;
cin >>Node->procname>>Node->needOftime;
Node->runtime = 0;
Node->state ="就绪";
Node->Counter = 0;
Node->pieceOftime = m;
cout <<"进程"<<Node->procname<<"创建完毕!"<<endl;
}
queue(Node);
}
return true;
}
void Runtime(int c)
{
run = ready;
ready = ready->next;
run->state = "运行";
Prinft(c);
while(run!=NULL)
{
run->runtime=run->runtime+1;
run->needOftime=run->needOftime-1;
run->Counter = run->Counter + 1;
if(run->needOftime==0)
{
run->state = "完成";
run->next = finish;
finish = run;
run = NULL;
if(ready!=NULL)
{
run = ready;
ready = ready->next;
}
}
else if(run->Counter == run->pieceOftime)
{
run->Counter = 0;
run->state = "就绪";
queue(run);
run=NULL;
if(ready!=NULL)
{
run = ready;
run->state = "运行";
ready = ready->next;
}
}
display(c);
}
}
int main()
{
int i;
cout <<"*******************************************"<<endl;
cout <<"* 1 优先数调度算法 2 循环时间片轮转算法*"<<endl;
cout <<"*************** 0 退出 *******************"<<endl;
cin >>i;
switch(i)
{
case 1:
CTProcessOfPri();
priority(i);
break;
case 2:
CTProcessOfRuntime();
Runtime(i);
break;
default:
break;
}
return 0;
{
time(& current_time);
}while((current_time-start_time)<t);
}
}
void Dtime(int t)
{
time_t current_time;
time_t start_time;
time(&start_time);
do
‘伍’ 如何用C语言实现动态分区分配算法的模拟
#define_CRT_SECURE_NO_WARNINGS1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#defineN10000
intn1;//空闲分区的个数
intn2;//作业区的个数
structkongxian
{
intstart;//起址
intend;//结束
intlength;//长度
}kongxian[N];
structzuoye
{
intstart;//起址
intend;//结束
intlength;//长度
}zuoye[N];
intcmp1(constvoid*a,constvoid*b)
{
return(*(structkongxian*)a).start-(*(structkongxian*)b).start;
}
intcmp2(constvoid*a,constvoid*b)
{
return(*(structzuoye*)a).start-(*(structzuoye*)b).start;
}
voidinit()
{
n1=1;//初始时只有一个空闲区
n2=0;//初始没有作业
kongxian[0].start=0;
kongxian[0].end=511;
kongxian[0].length=512;
}
voidprint1()//打印空闲分区
{
inti;
for(i=0;i<n1;i++)
printf("空闲分区ID:%d起止:%d结束:%d长度:%d ",i,kongxian[i].start,kongxian[i].end,kongxian[i].length);
}
voidprint2()//打印作业分区
{
inti;
for(i=0;i<n2;i++)
printf("作业分区ID：%d起止:%d结束:%d长度:%d ",i,zuoye[i].start,zuoye[i].end,zuoye[i].length);
}
intmain()
{
inti,j,t,len,flag,id;
intfront,middle,behind;
intt1,t2;
init();
print1();
printf("输入1装入新作业，输入0回收作业，输入-1结束 ");
while(scanf("%d",&t)!=EOF)
{
if(t==1)//装入新作业
{
printf("请输入作业的占用空间的长度");
scanf("%d",&len);
flag=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].length>=len)//首次适应算法
{
flag=1;
break;
}
}
if(!flag)
{
printf("内存分配失败 ");
}
else
{
//将该作业加入作业区里
zuoye[n2].start=kongxian[i].start;
zuoye[n2].end=zuoye[n2].start+len;
zuoye[n2].length=len;
n2++;//作业数加1
if(kongxian[i].length==len)//该分区全部用于分配，删除该空闲分区
{
for(j=i;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
}
else//该空闲分区部分用于分配，剩余的留在空闲分区中
{
kongxian[i].start+=len;
kongxian[i].length-=len;
}
}
}
elseif(t==0)
{
printf("输入要回收的作业ID");
scanf("%d",&id);
front=middle=behind=0;
for(i=0;i<n1;i++)
{
if(kongxian[i].start>zuoye[id].end)
break;
if(kongxian[i].end==zuoye[id].start)//待回收的作业上面有空闲分区
{
front=1;
t1=i;
}
if(kongxian[i].start==zuoye[id].end)//待回收的作业下面有空闲分区
{
behind=1;
t2=i;
}
}
if(!front&&!behind)//待回收的作业上下均没有空闲分区
{
kongxian[n1].start=zuoye[id].start;
kongxian[n1].end=zuoye[id].end;
kongxian[n1].length=zuoye[id].length;
n1++;//空闲分区增加一个
qsort(kongxian,n1,sizeof(structkongxian),cmp1);//插入空闲分区后排序
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(front&&behind)//待回收的作业上下均有空闲分区
middle=1;
if(front&&!middle)//合并待回收的作业和上面的空闲分区
{
kongxian[t1].end+=zuoye[id].length;
kongxian[t1].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(middle)//合并待回收的作业和上下的空闲分区
{
kongxian[t1].end=kongxian[t2].end;
kongxian[t1].length+=(zuoye[id].length+kongxian[t2].length);
//删除空闲分区t2
for(j=t2;j<n1-1;j++)
{
kongxian[j].start=kongxian[j+1].start;
kongxian[j].end=kongxian[j+1].end;
kongxian[j].length=kongxian[j+1].length;
}
n1--;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
if(behind&&!middle)//合并待回收的作业和下面的分区
{
kongxian[t2].start-=zuoye[id].length;
kongxian[t2].length+=zuoye[id].length;
for(j=id;j<n2-1;j++)//在作业分区中删除该作业
{
zuoye[j].start=zuoye[j+1].start;
zuoye[j].end=zuoye[j+1].end;
zuoye[j].length=zuoye[j+1].length;
}
n2--;
}
}
else
{
printf("操作结束 ");
break;
}
print1();
print2();
}
return0;
}
‘陆’ 请问谁有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);
}
}
但是这个算法可能会有点小问题，你研究一下看看，多多少少有帮助的
‘柒’ c语言算法
离散数学离散数学作为计算机学科的基础是竞赛中涉及最多的数学分支，重中之重又在于图论和组合数学，尤其是图论。图论之所以运用最多是因为它的变化最多，而且可以轻易地结合基本数据结构和许多算法的基本思想，较多用到的知识包括连通性判断、DFS和BFS，关节点和关键路径、欧拉回路、最小生成树、最短路径、二部图匹配和网络流等等。虽然这部分的比重很大，但是往往也是竞赛中的难题所在，如果有初学者对于这部分的某些具体内容暂时感到力不从心，也不必着急，可以慢慢积累。组合数学竞赛中设计的组合计数问题大都需要用组合数学来解决，组合数学中的知识相比于图论要简单一些，很多知识对于小学上过奥校的同学来说已经十分熟悉，但是也有一些部分需要先对代数结构中的群论有初步了解才能进行学习。组合数学在竞赛中很少以难题的形式出现，但是如果积累不够，任何一道这方面的题目却都有可能成为难题。数论以素数判断和同余为模型构造出来的题目往往需要较多的数论知识来解决，这部分在竞赛中的比重并不大，但只要来上一道，也足以使知识不足的人冥思苦想上一阵时间。素数判断和同余最常见的是在以密码学为背景的题目中出现，在运用密码学常识确定大概的过程之后，核心算法往往要涉及数论的内容。计算几何计算几何相比于其它部分来说是比较独立的，就是说它和其它的知识点很少有过多的结合，较常用到的部分包括—线段相交的判断、多边形面积的计算、内点外点的判断、凸包等等。计算几何的题目难度不会很大，但也永远不会成为最弱的题。线性代数对线性代数的应用都是围绕矩阵展开的，一些表面上是模拟的题目往往可以借助于矩阵来找到更好的算法。 ~
‘捌’ C语言模拟FIFO算法，随机生成320条指令，有四块物理块，为什么错了
这可是hen宝贵的啊
#include
#include
#include
#include
#define Bsize 4
typedef struct BLOCK//声明一种新类型——物理块类型
{
int pagenum;//页号
int accessed;//访问字段，其值表示多久未被访问
}BLOCK;
int pc;//程序计数器，用来记录指令的序号
int n;//缺页计数器，用来记录缺页的次数
static int temp[320];//用来存储320条随机数
BLOCK block[Bsize]; //定义一大小为4的物理块数组
//*************************************************************
void init( ); //程序初始化函数
int findExist(int curpage);//查找物理块中是否有该页面
int findSpace( );//查找是否有空闲物理块
int findReplace( );//查找应予置换的页面
void display ( );//显示
void suijishu( );//产生320条随机数,显示并存储到temp[320]
void pagestring( );//显示调用的页面队列
void OPT( );//OPT算法
void LRU( );// LRU算法
void FIFO( );//FIFO算法
//*************************************************************
void init( )
{
for(int i=0;i<Bsize;i++)
{
block[i].pagenum=-1;
block[i].accessed=0;
pc=n=0;
}
}
//-------------------------------------------------------------
int findExist(int curpage)
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == curpage )
return i;//检测到内存中有该页面，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findSpace( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum == -1)
return i;//找到空闲的block，返回block中的位置
}
return -1;
}
//-------------------------------------------------------------
int findReplace( )
{
int pos = 0;
for(int i=0; i<Bsize; i++)
{
if(block[i].accessed >block[pos].accessed)
pos = i;//找到应予置换页面，返回BLOCK中位置
}
return pos;
}
//-------------------------------------------------------------
void display( )
{
for(int i=0; i<Bsize; i++)
{
if(block[i].pagenum != -1)
{ printf(" %02d",block[i].pagenum);}
}
cout<<endl;
}
//-------------------------------------------------------------
void suijishu( )
{ int flag=0;
cin>>pc;
cout<<"******按照要求产生的320个随机数：*******"<<endl;
for(int i=0;i<320;i++)
{
temp[i]=pc;
if(flag%2==0) pc=++pc%320;
if(flag==1) pc=rand( )% (pc-1);
if(flag==3) pc=pc+1+(rand( )%(320-(pc+1)));
flag=++flag%4;
printf(" %03d",temp[i]);
if((i+1)%10==0) cout<<endl;
}
}
//-------------------------------------------------------------
void pagestring( )
{
for(int i=0;i<320;i++)
{
printf(" %02d",temp[i]/10);
if((i+1)%10==0) cout<<endl;
}
}
//-------------------------------------------------------------
void OPT( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace ( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
for(int k=0;k<Bsize;k++)
{
for(int j=i;j<320;j++)
{
if(block[k].pagenum!= temp[j]/10)
{
block[k].accessed = 1000;
}//将来不会用，设置为一个很大数
else
{
block[k].accessed = j;
break;
}
}
}
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void LRU( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
}
}
else block[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1
for(int j=0; j<4; j++)
{block[j].accessed++;}
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//-------------------------------------------------------------
void FIFO( )
{
int exist,space,position ;
int curpage;
for(int i=0;i<320;i++)
{
if(i%100==0) getch( );
pc=temp[i];
curpage=pc/10;
exist = findExist(curpage);
if(exist==-1)
{
space = findSpace( );
if(space != -1)
{
block[space].pagenum = curpage;
display( );
n=n+1;
}
else
{
position = findReplace( );
block[position].pagenum = curpage;
display( );
n++;
block[position].accessed--;
}
}
for(int j=0; j<Bsize; j++)
block[j].accessed++;
}
cout<<"缺页次数:"<<n<<endl;
cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;
}
//*************************************************************
void main( )
{
int select;
cout<<"请输入第一条指令号(0~320)：";
suijishu( );
cout<<"*****对应的调用页面队列*******"<<endl;
pagestring( );
do
{
cout<<"****************************************"<<endl;
cout<<"------1:OPT 2:LRU 3:FIFO 4:退出-----"<<endl;
cout<<"****************************************"<<endl;
cout<<" 请选择一种页面置换算法:";
cin>>select;
cout<<"****************************************"<<endl;
init( );
switch(select)
{
case 1:cout<<"最佳置换算法OPT:"<<endl;
cout<<"*****************"<<endl;
OPT( );
break;
case 2:cout<<"最近最久未使用置换算法LRU:"<<endl;
cout<<"**************************"<<endl;
LRU( );
break;
case 3:cout<<"先进先出置换算法FIFO:"<<endl;
cout<<"*********************"<<endl;
FIFO( );
break;
default: ;
}
}while(select!=4);
}
你试试可以不，应该没问题的
要注意这是用C++编写的，你改一下就可以用了