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);
}
}

}