scan算法c语言

❶ 小学生四则算法 c语言编写

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
int scan()
{
char s[100];
int i,t,z=0;
do
{
z=0;

gets(s);
for(i=0;s[i]!='\0';i++)
if(s[i]<'0' || s[i]>'9') break;
if(i>=strlen(s))
for(t=0;s[t]!='\0';t++)
z=z*10+((int)s[t]-48);
else
printf("您的输入有误，请重新输入");
}
while(i<strlen(s));
return(z);
}

int x=1,y=1,choice=0,sum=0,right=0,z=0,answer;
float precent;
char fuhao;
void suiji()
{
srand(time(NULL));
x=rand()%100+1;
y=rand()%100+1;
}

void choose()
{
int yunsuan(int,int,int);
if(sum==0) precent=0.0;
else precent=(float)right/sum;
printf("\n如需进行加减乘除运算测试，请分别输入1、2、3、4\n");
printf("如需退出请输入5\n");
choice=scan();
switch(choice)
{
case 1:printf("欢迎来到加法运算测试系统,如需退出请输入9999\n");fuhao='+';break;
case 2:printf("欢迎来到减法运算测试系统,如需退出请输入9999\n");fuhao='-';break;
case 3:printf("欢迎来到乘法运算测试系统,如需退出请输入9999\n");fuhao='*';break;
case 4:printf("欢迎来到除法运算测试系统,如需退出请输入9999\n");fuhao='/';break;
case 5:printf("本次测试愉快，欢迎下次再来测试\n");
printf("本次共做%d道题，其中%d道正确，正确率为%f\n",sum,right,precent);
break;
default:printf("您的输入有误，请重新输入\n");choose();
}
}

int ans(int x,int y,int choice)
{
switch(choice)
{
case 1:z=x+y;break;
case 2:z=x-y;break;
case 3:z=x*y;break;
case 4:z=x/y;break;
}
return(z);
}
void yunsuan()
{
suiji();
printf("%d%c%d=",x,fuhao,y);
z=ans(x,y,choice);
answer=scan();
if(z==answer)
{
printf("正确\n");
right++;sum++;
yunsuan();
}
else if(answer==9999) choose();
else
{
printf("不正确, 正确答案为%5d\n",z);
sum++;
yunsuan();
}
}
void main()
{
printf("欢迎来到四则运算测试系统\n");
choose();
while(choice!=5)
yunsuan();
}

❷ 磁盘调度 算法

(1)FCFS(先来先服务):
143-86=57
147-86=61
147-91=56
177-91=86
177-94=97
150-94=56
150-102=48
175-102=73
175-130=45
57+61+56+86+97+56+48+73+45=579
(2)SSTF(最短寻道时间优先)：
寻道顺序：143（当前），147，150，130，102，94，91，86，175，177；
4+3+20+28+8+3+5+89+2=162
(3)SCAN：
当前方向：从143#向磁道号增加的方向
依次访问：143（当前），147，150，175，177
再从递减方向：130，102，94，91，86
4+3+25+2+47+28+8+3+5=125
(4)LOOK:(即SCAN，电梯调度算法)
(5)CSCAN:
当前方向：从143#向磁道号增加的方向
依次访问：143（当前），147，150，175，177
再从0开始增加方向：86,91,94,102,130
4+3+25+2+91+5+3+8+28=169

❸ scan与cscan有什么异同

CSCAN美国Horner公司开发的一种通信网络，采用Controller Area Network技术。
循环扫描CSCAN（Circular SCAN）

为了减少SCAN算法造成的某些进程的请求被严重推迟，CSCAN算法规定磁头单向移动。

❹ 目前常用的磁盘调度算法有哪几种每种算法优先考虑的问题是什么

(1)先来先服务(FCFS，First-Come First-Served)
此算法根据进程请求访问磁盘的先后次序进行调度。
(2)最短寻道时间优先(SSTF ，ShortestSeekTimeFirst)
该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，但这种调度算法却不能保证平均寻道时间最短。
(3)扫描(SCAN)算法
SCAN算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
(4)循环扫描(CSCAN)算法
CSCAN算法规定磁头单向移动，避免了扫描算法导致的某些进程磁盘请求的严重延迟。
(5) N-Step-SCAN和FSCAN调度算法
1) N-Step-SCAN算法。为克服前述SSTF、SCAN、CSCAN等调度算法都可能出现的磁臂停留在某处不动的情况即磁臂粘着现象，将磁盘请求队列分成若干个长度为N的子队列，按先来先服务算法依次处理这些子队列，而各队列分别以扫描算法进行处理。
2) FSCAN算法
FSCAN算法实质上是N步SCAN算法的简化。它只将磁盘请求访问队列分成两个子队列。一是当前所有请求磁盘I/O的进程形成的队列，由磁盘调度按SCAN算法进行处理。另一个队列则是在 扫描期间，新出现的所有请求磁盘I/O进程的队列，放入另一等待处理的请求队列。这样，所有的新请求都将被推迟到下一次扫描时处理。

❺ 我需要用C++程序做的Nstep-scan

自己看着修改了，修改下还不简单。

#include "stdio.h"
#include "stdlib.h"

void CopyL(int Sour[],int Dist[] ,int x); //数组Sour复制到数组Dist，复制到x个数
void SetDI(int DiscL[]); //随机生成磁道数
void Print(int Pri[],int x); //打印输出数组Pri
void DelInq(int Sour[],int x,int y); //数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void FCFS(int Han,int DiscL[]); //先来先服务算法(FCFS)
void SSTF(int Han,int DiscL[]); //最短寻道时间优先算法(SSTF)
int SCAN(int Han,int DiscL[],int x,int y); //扫描算法(SCAN)
void CSCAN(int Han,int DiscL[]); //循环扫描算法(CSCAN)
void N_Step_SCAN(int Han1,int DiscL[]); //N步扫描算法(NStepScan)
void PaiXu(); //寻道长度由低到高排序
void Pri();
int NAll=0;
int Best[5][2]; //用作寻道长度由低到高排序时存放的数组
int Limit=0; //输入寻找的范围磁道数i
int Jage;
float Aver=0;

int main()
{
int i;
int DiscLine[10]; //声明准备要生成的随机磁道号的数组
int Hand; //磁道数
int Con=1;
int n;
while (Con==1)
{
Jage=0;
printf("\n 请输入初始的磁道数(0<n<65536):");
scanf("%d",&Hand);
printf("\n+ 输入寻找的范围:");
scanf("%d",&Limit);
if (Limit>65536)
{
printf("超出范围!");
}
else
{
printf(" ╭═══════════════╮ \n");
printf(" ║ 操作系统课程设计 ║ \n");
printf(" ╭═════┤ 磁盘调度算法 ├═════╮\n");
printf(" ║ ║ ║ ║\n");
printf(" ║ ╰═══════════════╯ ║\n");
printf(" ║ 1.先来先服务算法(FCFS) ║\n");
printf(" ║ ║\n");
printf(" ║ 2.最短寻道时间优先算法(SSTF) ║\n");
printf(" ║ ║\n");
printf(" ║ 3.扫描算法(SCAN) ║\n");
printf(" ║ ║\n");
printf(" ║ 4.循环扫描算法(CSCAN) ║\n");
printf(" ║ ║\n");
printf(" ║ 5.N步扫描算法(NStepScan) ║\n");
printf(" ║ ║\n");
printf(" ║ 6.各类算法的比较 ║\n");
printf(" ║ ║\n");
printf(" ║ ║\n");
printf(" ║ ╭———————————————————————╮ ║\n");
printf(" ╰═┤ 请输入你的选择的算法(输入0离开) ├═╯\n");
printf(" ╰———————————————————————╯\n");
scanf("%d",&n);
if (n==0) exit(0);
printf("\n");
switch (n)
{
case 1:
SetDI(DiscLine); //随机生成磁道数
FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
break;
case 2:
SetDI(DiscLine); //随机生成磁道数
SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
break;
case 3:
SetDI(DiscLine); //随机生成磁道数
SCAN(Hand,DiscLine,0,9); //扫描算法(SCAN)
break;
case 4:
SetDI(DiscLine); //随机生成磁道数
CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)
break;
case 5:
SetDI(DiscLine); //随机生成磁道数
N_Step_SCAN(Hand,DiscLine); //N步扫描算法(NStepScan)
break;
case 6:
SetDI(DiscLine); //随机生成磁道数
FCFS(Hand,DiscLine); //先来先服务算法(FCFS)
SSTF(Hand,DiscLine); //最短寻道时间优先算法(SSTF)
SCAN(Hand,DiscLine,0,9); //扫描算法(SCAN)
CSCAN(Hand,DiscLine); //循环扫描算法(CSCAN)
N_Step_SCAN(Hand,DiscLine); //N步扫描算法(NStepScan)
PaiXu(); //寻道长度由低到高排序
printf("\n\n+ 寻道长度由低到高排序:");
for (i=0;i<5;i++)
{
printf("%4d ",Best[i][0]);
}
break;
}
printf("\n\n+ 是否继续(按0结束,按1继续)?");
scanf("%5d",&Con);
}

}
}

//数组Sour复制到数组Dist，复制到x个数
void CopyL(int Sour[],int Dist[] ,int x)
{
int i;
for (i=0;i<=x;i++)
{
Dist[i]=Sour[i];
}
}
//打印输出数组Pri
void Print(int Pri[],int x)
{
int i;
for (i=0;i<=x;i++)
{
printf("%5d",Pri[i]);
}
}
//随机生成磁道数
void SetDI(int DiscL[])
{
int i;
for (i=0;i<=9;i++)
{
DiscL[i]=rand()%Limit;//随机生成10个磁道号
}
printf("+ 需要寻找的磁道号:");
Print(DiscL,9); //输出随机生成的磁道号
printf("\n");
}
//数组Sour把x位置的数删除，并把y前面的数向前移动，y后的数保持不变(即会出现2个y)
void DelInq(int Sour[],int x,int y)
{
int i;
for (i=x;i<y;i++)
{
Sour[i]=Sour[i+1];
x++;
}
}
//先来先服务算法(FCFS)
void FCFS(int Han,int DiscL[])
{
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int i,k,All,Temp; //Temp是计算移动的磁道距离的临时变量
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照FCFS算法磁道的访问顺序为:");
All=Han-RLine[0];
for (i=0;i<=9;i++)
{
Temp=RLine[0]-RLine[1];//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离
if (Temp<0)
Temp=(-Temp);//移动磁道数为负数时,算出相反数作为移动磁道数
printf("%5d",RLine[0]);
All=Temp+All;//求全部磁道数的总和
DelInq(RLine,0,k);//每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=1; //Best[][0]存放算法的序号为:1
Jage++;//排序的序号加1
Aver=((float) All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//最短寻道时间优先算法(SSTF)
void SSTF(int Han,int DiscL[])
{
int i,j,k,h,All;
int Temp; //Temp是计算移动的磁道距离的临时变量
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Min;
All=0; //统计全部的磁道数变量
k=9; //限定10个的磁道数
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照SSTF算法磁道的访问顺序为:");
for (i=0;i<=9;i++)
{
Min=64000;
for (j=0;j<=k;j++) //内循环寻找与当前磁道号最短寻道的时间的磁道号
{
if (RLine[j]>Han) //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if (Temp<Min) //如果每求出一次的移动距离小于Min，执行下一句
{
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min; //统计一共移动的距离
printf("%5d",RLine[h]);
Han=RLine[h];
DelInq(RLine,h,k); //每个磁道数向前移动一位
k--;
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=2;//Best[][0]存放算法的序号为:2
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//扫描算法(SCAN)
int SCAN(int Han,int DiscL[],int x,int y)
{
int j,n,k,h,m,All;
int t=0;
int Temp;
int Min;
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Order;
Order=1;
k=y;
m=2; //控制while语句的执行，即是一定要使当前磁道向内向外都要扫描到
All=0; //统计全部的磁道数变量
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照SCAN算法磁道的访问顺序为:");
Min=64000;
for (j=x;j<=y;j++) //寻找与当前磁道号最短寻道的时间的磁道号
{
if (RLine[j]>Han) //如果第一个随机生成的磁道号大于当前的磁道号，执行下一句
Temp=RLine[j]-Han; //求出临时的移动距离
else
Temp=Han-RLine[j]; //求出临时的移动距离
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=j; //把最近当前磁道号的数组下标赋予h
}
}
All=All+Min;
printf("%5d",RLine[h]);
if (RLine[h]>=Han) //判断磁道的移动方向，即是由里向外还是由外向里
{
Order=0;
t=1;
}
Han=RLine[h];
DelInq(RLine,h,k); //每个磁道数向前移动一位
k--;
while (m>0)
{
if (Order==1) //order是判断磁盘扫描的方向标签，order是1的话，磁道向内移动
{
for (j=x;j<=y;j++)
{
h=-1;
Min=64000;
for (n=x;n<=k;n++) //判断离当前磁道最近的磁道号
{
if (RLine[n]<=Han)
{
Temp=Han-RLine[n];
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if (h!=-1)
{
All=All+Min; //叠加移动距离
printf("%5d",RLine[h]);
Han=RLine[h]; //最近的磁道号作为当前磁道
DelInq(RLine,h,k);
k--;
}
}
Order=0; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
else //order是0的话，磁道向外移动
{
for (j=x;j<=y;j++)
{
h=-1;
Min=64000;
for (n=x;n<=k;n++) //判断离当前磁道最近的磁道号
{
if (RLine[n]>=Han)
{
Temp=RLine[n]-Han;
if (Temp<Min)
{
Min=Temp; //Temp临时值赋予Min
h=n; //把最近当前磁道号的数组下标赋予h
}
}
}
if (h!=-1)
{
All=All+Min; //叠加移动距离
printf("%5d",RLine[h]);
Han=RLine[h]; //最近的磁道号作为当前磁道
DelInq(RLine,h,k);
k--;
}
}
Order=1; //当完成向内的移动，order赋予0，执行else语句，使磁道向外移动
m--; //向内完成一次，m减一次，保证while循环执行两次
}
}
NAll=NAll+All;
if ((y-x)>5)
{
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=3;//Best[][0]存放算法的序号为:3
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
if (t==1) printf("\n+ 磁道由内向外移动");
else printf("\n+ 磁道由外向内移动");
return(Han);
}
//循环扫描算法(CSCAN)
void CSCAN(int Han,int DiscL[])
{

int j,h,n,Temp,m,k,All,Last,i;
int RLine[10]; //将随机生成的磁道数数组Discl[]复制给数组RLine[]
int Min;
int tmp=0;
m=2;
k=9;
All=0; //统计全部的磁道数变量
Last=Han;
CopyL(DiscL,RLine,9); //复制磁道号到临时数组RLine
printf("\n+ 按照CSCAN算法磁道的访问顺序为:");
while (k>=0)
{
for (j=0;j<=9;j++) //从当前磁道号开始，由内向外搜索离当前磁道最近的磁道号
{
h=-1;
Min=64000;
for (n=0;n<=k;n++)
{
if (RLine[n]>=Han)
{
Temp=RLine[n]-Han;
if (Temp<Min)
{
Min=Temp;
h=n;
}
}
}
if (h!=-1)
{
All=All+Min; //统计一共移动的距离
printf("%5d",RLine[h]);
Han=RLine[h];
Last=RLine[h];
DelInq(RLine,h,k);
k--;
}
}
if (k>=0)
{
tmp=RLine[0];
for (i=0;i<k;i++)//算出剩下磁道号的最小值
{
if (tmp>RLine[i]) tmp=RLine[i];
}
Han=tmp;//把最小的磁道号赋给Han
Temp=Last-tmp;//求出最大磁道号和最小磁道号的距离差
All=All+Temp;
}
}
Best[Jage][1]=All;//Best[][1]存放移动磁道数
Best[Jage][0]=4;//Best[][0]存放算法的序号为:4
Jage++;//排序序号加1
Aver=((float)All)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",All);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//N步扫描算法(NStepScan)
void N_Step_SCAN(int Han1,int DiscL[])
{
int i,m,k;
int RLine1[10];
NAll=0;
m=2;
k=9; //限定10个的磁道数
i=-1;
CopyL(DiscL,RLine1,9); //复制磁道号到临时数组RLine
printf("\n+ 按照N_Step_SCAN算法磁道的访问顺序为:");
for (m=0;m<2;m++) //由于限定10磁道数，将10个磁道数分为两组，每组5个磁道数，每个组按照SCAN算法执行，该循环循环2次
{
Han1=SCAN(Han1,RLine1,i+1,i+5);
i=i+5;
}
Best[Jage][1]=NAll;//Best[][1]存放移动磁道数
Best[Jage][0]=5;//Best[][0]存放算法的序号为:5
Aver=((float)NAll)/10;//求平均寻道次数
printf("\n+ 移动磁道数:<%5d> ",NAll);
printf("\n+ 平均寻道长度:*%0.2f* ",Aver);
}
//寻道长度由低到高排序
void PaiXu()
{
int i,j,Temp;
for (i=0;i<5;i++)
{
for (j=0;j<4;j++)
{
if (Best[j][1]>Best[j+1][1]) //如果前一个算法的移动磁道距离大于后一个移动磁道数，执行下面语句
{
Temp=Best[j+1][1]; //从这起下三行执行冒泡法将移动距离大小排序，排完后则执行每个算法的排序
Best[j+1][1]=Best[j][1];
Best[j][1]=Temp;
Temp=Best[j+1][0]; //将每个算法的序号用冒泡法排序
Best[j+1][0]=Best[j][0];
Best[j][0]=Temp;
}
}
}
}

❻ C语言编程：从键盘上输入一个十进制数，将其转换成八进制数，然后输出。

非递归算法：
#include <iostream>
using namespace std;
#include <math.h>
#define MAXSIZE 20
typedef struct Stack
{
char node[MAXSIZE];
int top;
}Stack;

int main()
{

Stack s;
s.top=-1;
int n;
cout<<"请输入十进制数："<<endl;
cin>>n;
int m;
cout<<"请输入要转化的进制数："<<endl;
cin>>m;
int q=n;
while(n!=0)
{
q=n%m;
n=n/m;
s.top++;
if(q<10)
s.node[s.top]=q+48;
else
s.node[s.top]=(q-9)+64;
}
while(s.top>=0)
{
cout<<s.node[s.top--];
}

return 0;
}

递归算法：（未采用数组存储）
#include <iostream>
using namespace std;

#define N 8
void print(int M);
int main()
{
print(100);

return 0;
}
void print(int M)
{
int n=M%N;
M=M/N;
if(M!=0)
print(M);
cout<<n;
}

❼ 电脑技术 操作系统 LOOK SCAN算法

C-LOOK=10到5到90到80到70到60到20=160
C-SCAN=10到5到0到199到90到80到70到60到20=388
LOOK=10到5到20到60到70到80到90=90
SCAN=10到5到0到20到60到70到80到90=100

❽ 这是个关于SCAN算法的c语言描述，程序无错，运行有错

你的代码是有问题的，网络这个没法完整的上传代码

#include<stdio.h>

#include<stdlib.h>

#include<malloc.h>

#include<math.h>

typedefintstatus;

#defineOK1#defineERROR0

typedefstructlikelist

{

intdata;

structlikelist*front,*next;//建立双向链表

}Listnode;

Listnode*Create_list(Listnode*head,intn)//建立链表

{

Listnode*p,*q;

inti;

head=(Listnode*)malloc(sizeof(Listnode));

if(!head)

{

exit(-1);//创建不成功则退出程序

}

head->next=NULL;

p=head->next;

q=head;

printf("请输入%d个进程所要访问的磁道号:",n);

for(i=0;i<n;i++)

{

p=(Listnode*)malloc(sizeof(Listnode));

if(!p)

{

exit(-1);

}

q->next=p;

scanf("%d",&p->data);

p->front=q;

p->next=NULL;

q=p;

}

printf("输入磁道号已经完成 ");//用于测试程序在哪里执行出错

returnhead;

}

Listnode*Sort_list(Listnode*head)//对链表排序

{

inta;

if(!head->next)

{

printf("表空！");

exit(-1);

}

Listnode*p,*q;

p=head->next;

q=p->next;

for(;q->next!=NULL;p=p->next,q=q->next)

{

if((p->data)>(q->data))

{

a=p->data;

p->data=q->data;

q->data=a;

}

}/*while(q->next!=NULL){if((p->data)>(q->data)){a=p->data;p->data=q->data;q->data=a;}p=p->next;q=q->next;}*/

returnhead;

}

voidFangwen_list(Listnode*head,intn,intm)//访问链表，向磁道增加的方向，m用于记录开始访问的磁道号，n记录总共磁道号数目

{

Listnode*p,*q;//定义指向节点的指针

inti,j;

floatdistance=0;

floatsum=0;

floatave;

p=head->next;

printf("将要从%d号磁道向磁道号增加的方向访问: ",m);

printf("被访问的下一个磁道号 本次移动的距离 ");

for(i=0;i<n;i++)

{

if(p->data>=m)

{

q=p->front;

j=i;

break;

}

else

{

continue;

}

}

for(;i<n;i++)

{

printf(" %d",p->data);

distance=(float)fabs(m-(p->data));

m=p->data;

sum=(float)(sum+distance);

printf(" %f ",distance);//用于格式化的输出，

p=p->next;

}

printf(" ");

/*

for(;q!=head;)

{

printf(" %d",q->data);

distance=(float)fabs(m-q->data);

m=q->data;

sum=(float)(sum+distance);

printf(" %f ",distance);

q=q->front;

}

printf(" ");

*/

ave=(float)sum/n;//计算出平均长度

printf("平均寻道长度为:%.2f ",ave);

}

intmain()

{

Listnode*head;

intn;

intm;

printf("请输入进程要访问的磁道的总数:");

scanf("%d",&n);

head=Create_list(head,n);//链表返回头指针应该赋值，

Sort_list(head);

printf("请输入你要最开始访问的磁道号:");

scanf("%d",&m);

Fangwen_list(head,n,m);

system("pause");

return0;

}

❾ 请帮我把这个C语言小程序改为C++的，通过了追加分70+20一定给

#include <stdio.h>

void main()
{
char algorithm;
float l,m;
int a[100];
int direct,begin,i,j,t,k,n=0;
printf("请输入要调度序列的个数：\n");
scanf("%d",&n);
printf("请输入要调度的序列：\n");
for(i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
printf("\n");
for(i=0;i<n-2;i++)
{
for(j=n-1;j>=1;j--)
{
if(a[j]<a[j-1])
{
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
}
}
}
/* for(i=0;i<n;i++)
cout<<a[i]<<endl;*/
printf("请选择磁盘调度算法,其中s代表scan算法，c代表cscan算法:\n");
//cin>>algorithm;
scanf("%c",&algorithm);
//以下为scan算法实现磁盘调度
if(algorithm=='s')
{

printf("请输入开始的磁盘序列号：\n");
scanf("%d",&begin);
printf("\n");
for(i=0;i<n;i++)
{
if(a[i]==begin)
k=i;
}

printf("请输入访问方向,其中1为增大方向，0为减小方向：\n");
scanf("%d",&direct);
printf("\n");
m=float(n)-1;
if(direct==1)
{
for(i=k;i<n;i++)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
for(i=k-1;i>=0;i--)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
//cout<<endl;
printf("\n");
l=((a[n-1]-a[k])+(a[n-1]-a[0]))/m;
//cout<<"平均寻道长度为："<<l<<endl;
printf("平均寻道长度为：%d\n",l);

}
else
{
for(i=k;i>=0;i--)
//cout<<a[i]<<" ";
printf("%d ",a[i]);
for(i=k+1;i<n;i++)
printf("%d ",a[i]);
printf("\n");
l=((a[k]-a[0])+(a[n-1]-a[0]))/m;
printf("平均寻道长度为：%d\n",l);
}
}
//以下为cscan算法实现调度
else
{
//cout<<"请输入开始的磁盘序列号："<<endl;
printf("请输入开始的磁盘序列号：\n");
//cin>>begin;
// cout<<endl;
scanf("%d",&begin);
printf("\n");
for(i=0;i<n;i++)
{
if(a[i]==begin)
k=i;
}
//cout<<"请输入访问方向,其中1为增大方向，0为减小方向："<<endl;
printf("请输入访问方向,其中1为增大方向，0为减小方向：\n");
//cin>>direct;
//cout<<endl;
scanf("%d",&direct);
printf("\n");
m=float(n)-1;
if(direct==1)
{
for(i=k;i<n;i++)
printf("%d ",a[i]);
for(i=0;i<k;i++)
printf("%d ",a[i]);
printf("\n");
l=((a[n-1]-a[k])+(a[n-1]-a[0])+(a[k-1]-a[0]))/m;
printf("平均寻道长度为：%d\n",l);
}
else
{
for(i=k;i>=0;i--)
printf("%d ",a[i]);
for(i=n-1;i>k;i--)
printf("%d ",a[i]);
printf("\n");
l=((a[k]-a[0])+(a[n-1]-a[0])+(a[n-1]-a[k+1]))/m;
printf("平均寻道长度为：%d\n",l);
}
}

}