磁盘调度算法

磁盘调度主要应用于多道批处理系统中，以满足多个进程对磁盘读/写的请求。常用的磁盘调度算法有以下四种：

1. 先来先服务FCFS
此算法的优点是公平、简单，且每个进程 的请求都能依次得到处理，不会出现某进程的请求长期得不到 满足的情况。但此算法由于未对寻道进行优化，致使平均寻道 时间可能较长。 FCFS算法仅适用于请求磁盘I／O的进程数目较 少的场合。
代码写出来就是怎么输入就怎们输出。

2. 最短寻道时间优先SSTF
该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短。但这种调度算法不能保证平均寻道时间最短。

3. 扫描算法SCAN
扫描算法又叫做电梯算法。当有访问请求时，磁头按一个方向移动，判断该方向上是否还有访问请求，如果有则继续扫描；否则改变移动方向。相当于最短寻道再加上了一个方向。

4. 循环扫描算法CSCAN。
CSCAN算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时， 磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

举个栗子吧

现有一个磁盘读写请求队列：55， 58，39，18，90，160，150，38，184，磁头当前位置为 100。

1.若采用 FCFS算法，序列就是：55、58、39、18、90、160、150、38、184，
移动距离依次为45、3、19、21、72、70、10、112、146 一共寻道9次，平均寻道时间是 55.3。

2.若采用 SSTF算法，序列就是：90、58、55、39、38、18、150、160、184
移动距离依次为10、32、3、16、1、20、132、10、24 一共寻道9次，平均寻道时间是 27.6。

3.若采用 SCAN算法，序列就是：150、160、184、90、58、55、39、38、18
移动距离依次为50、10、24、94、32、3、16、1、20 一共寻道9次，平均寻道时间是 27.8。

4.若采用 CSCAN算法，序列就是：150、160、184、18、38、39、55、58、90
移动距离依次为50、10、24、166、20、1、16、3、32 一共寻道9次，平均寻道时间是 35.8。

C语言代码如下 // 写了前三种算法
输入时，第一个数据应该输入磁头当前所在磁道

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define max 20
int CN;//柱面个数  Cylindrical  Number
int CO[max];//柱面顺序 Cylindrical Order
void FCFS()
{
	printf("\n---------------------FCFS-----------------------\n");
	int sum = 0,i;
	printf("柱面顺序: ");
	for (i = 1; i < CN; i++)
		printf("%-4d", CO[i]);
	printf("\n移动距离: ");
	for (i = 1; i < CN; i++)
	{
		int j = abs(CO[i] - CO[i - 1]);
		printf("%-4d", j);
		sum += j;
	}
	  printf("\n一共移动了%d个柱面\n", sum);
}
void SSTF()
{
	printf("\n---------------------SSTF-----------------------\n");
	int i, j, copy[max];
	int pos,min,temp;
	int distance[max] = { 0 };
	for (i = 0; i < CN; i++)
	{
		copy[i] = CO[i];
	}
		for (i = 1; i < CN; i++)
		{
			pos = i;
			min = abs(copy[i] -copy[i - 1]);
			for (j = i + 1; j < CN; j++)
			{
				if (abs(copy[j] - copy[i - 1]) < min)
				{
					min = abs(copy[j] - copy[i - 1]);
					pos = j;
				}
			}
			distance[i] = min;
			if (pos != i)
			{
				temp = copy[pos];
				copy[pos] = copy[i];
				copy[i] = temp;
			}
		}
		printf("柱面顺序: ");
		for (i = 1; i < CN; i++)
			printf("%-4d", copy[i]);
		printf("\n移动距离: ");
		for (i = 1; i < CN; i++)
		{
			j = distance[i];
			printf("%-4d", j);
			distance[0] += j;
		}
		printf("\n一共移动了%d个柱面\n",distance[0]);
	
}
void SCAN()
{
	printf("\n---------------------SCAN-----------------------\n");
	int choice,copy[max]; 
	printf("请选择磁头移动方向 1.由外向里  2.由里向外 :  ");
	scanf("%d", &choice);
	int i, j;
	if (choice == 1)
	{
		j = 0;
		for (i =0 ; i < CN;i++)
			if (CO[i]>=CO[0])
				copy[j++] = CO[i];
		int n = j-1;
		bool flag = true;
		while (n > 1 && flag)
		{
			flag = false;
			for (i = 0; i < n - 1;i++)
				if (copy[i]>copy[i + 1])
				{
					int temp = copy[i];
					copy[i] = copy[i + 1];
					copy[i + 1] = temp;
					flag = true;
				}
			n--;
		}
		int m = j;
		for (i = 1; i < CN; i++)
			if (CO[i] < CO[0])
				copy[j++] = CO[i];
		n = j;
		flag = true;
		while (n >= m&&flag)
		{
			flag = false;
			for (i = m; i < n - 1;i++)
				if (copy[i] < copy[i + 1])
				{
					int temp = copy[i];
					copy[i] = copy[i + 1];
					copy[i + 1] = temp;
					flag = true;
				}
			n--;
		}

	}
	else
	{
		j = 0;
		for (i =0 ; i < CN;i++)
			if (CO[i]<=CO[0])
				copy[j++] = CO[i];
		int n = j;
		bool flag = true;
		while (n > 1 && flag)
		{
			flag = false;
			for (i = 0; i < n - 1;i++)
				if (copy[i]<copy[i + 1])
				{
					int temp = copy[i];
					copy[i] = copy[i + 1];
					copy[i + 1] = temp;
					flag = true;
				}
			n--;
		}
		int m = j;
		for (i = 1; i < CN; i++)
			if (CO[i] > CO[0])
				copy[j++] = CO[i];
		n = j;
		flag = true;
		while (n >= m&&flag)
		{
			flag = false;
			for (i = m; i < n - 1;i++)
				if (copy[i] > copy[i + 1])
				{
					int temp = copy[i];
					copy[i] = copy[i + 1];
					copy[i + 1] = temp;
					flag = true;
				}
			n--;
		}

	}
	printf("柱面顺序: ");
	for (i = 1; i < CN; i++)
		printf("%-4d", copy[i]);
	int distance[max] = { 0 };
	printf("\n移动距离: ");
	for (i = 1; i < CN;i++ )
	{
		distance[i] = abs(copy[i] - copy[i - 1]);
		printf("%-4d", distance[i]);
		distance[0] += distance[i];
	}
	printf("\n一共移动了%d个柱面\n", distance[0]);
}
int  main()
{
	int i;

	Test:printf("输入柱面个数: "); scanf("%d", &CN);
	printf("输入柱面序列: ");
	for (i = 0; i < CN; i++)
		scanf("%d", &CO[i]);
	FCFS();
	SSTF();
	SCAN();
	int choice;
	printf("是否继续测试? 是(1) 否(0)  :   "); scanf("%d", &choice);
	if (choice == 1) goto Test;
	else return 0;
}

测试数据：磁头最初位置为 125 ，输入数据
125、86、147、91、177、94、150、102、175、130

磁盘调度算法通常有FCFS、SSTF、SCAN、CSAN这四种算法，以下是这种四种方法的总和：

#include<iostream>
using namespace std;
#include<math.h>
#include<iomanip>

int FF[10]={55,58,39,18,90,160,150,38,184};
int F[10];
int z[10]={100};
int Y[9];
float a_l=0;

void FCFS()
{    
    int i=0;    
    int temp=100;
    
    while(i<9)        
    {        
        Y[i]=fabs(temp-F[i]);        
        temp=F[i];        
        i++;        
    }
    
    cout<<"从100＃磁道开始"<<endl;    
    cout<<"访问到的磁道号"<<setw(10)<<"移动距离"<<endl;
    
    for(i=0;i<9;i++)        
    {        
        cout<<setw(10)<<F[i]<<setw(10)<<Y[i]<<endl;        
        a_l+=Y[i];        
    }
    cout<<"平均寻道距离:"<<setw(10)<<a_l/9<<endl;}

void SSTF()
{    
    int temp,temp1,k,w;    
    int j=9;    
    int a=0;    
    int i;
    
    while(j>0)        
    {
        temp=fabs(z[a]-F[0]);        
        k=temp;        
        int c=0;
        
        for(i=0;i<j;i++)            
        {            
            temp1=fabs(z[a]-F[i]);            
            if((k-temp1)<0)                
            {k=k;w=c;}            
            else                
            {k=temp1;w=i;c=i;}            
        }        
        Y[a]=k;        
        a++;        
        z[a]=F[w];        
        for(w;w<9;w++)            
        {            
            F[w]=F[w+1];            
        }        
        j--;        
    }
    
    int zz[9];    
    for(a=0;a<9;a++)        
    {zz[a]=z[a+1];}    
    cout<<"从100＃磁道开始"<<endl;    
    cout<<"访问到的磁道号"<<setw(10)<<"移动距离"<<endl;
    a_l=0;
    for(a=0;a<9;a++)        
    {cout<<setw(10)<<zz[a]<<setw(10)<<Y[a]<<endl;a_l+=Y[a];}    
    cout<<"平均寻道距离:"<<setw(10)<<a_l/9<<endl;}

void SCAN()
{    
    int aa[9],bb[9];    
    int start=z[0];    
    int i=0,j=0;    
    int ii=0,jj=0;    
    int temp;    
    int FF[9];while(i<9)        
    {        
        if((F[i]-start)>0)            
        {aa[ii]=F[i];ii++;i++;}        
        else {bb[jj]=F[i];jj++;i++;}        
    }    
    for(i=0;i<(ii-1);i++)        
    { for(j=i;j<ii;j++)    
    {        
        if(aa[i]>aa[j])
        {
            
            temp=aa[i];            
            aa[i]=aa[j];
            aa[j]=temp;}        
    }    
    }    
    for(i=0;i<(jj-1);i++)        
    {        
        for(j=i;j<jj;j++)            
        { if(bb[i]<bb[j])        
        {temp=bb[i];        
        bb[i]=bb[j];        
        bb[j]=temp;}        
        }        
    }    
    temp=z[0];    
    for(i=0;i<ii;i++)        
    {        
        Y[i]=aa[i]-temp;        
        temp=aa[i];        
        FF[i]=aa[i];}    
    for(j=0;j<jj;j++)        
    {        
        Y[i]=fabs(bb[j]-temp);        
        temp=bb[j];        
        FF[i]=bb[j];        
        i++;        
    }    
    cout<<"从100＃磁道开始,磁头方向为自外向里"<<endl;    
    cout<<"访问到的磁道号"<<setw(10)<<"移动距离"<<endl;    
    a_l=0;
    for(i=0;i<9;i++)        
    {        
        cout<<setw(10)<<FF[i]<<setw(10)<<Y[i]<<endl;        
        a_l+=Y[i];        
    }    
    cout<<"平均寻道距离:"<<setw(10)<<a_l/9<<endl;}    

void CSCAN()        
{        
    int aa[9],bb[9];        
    int start=z[0];        
    int i=0,j=0;        
    int ii=0,jj=0;        
    int temp;        
    int FF[9];        
    while(i<9)
    {            
        if((F[i]-start)>0)                
        {aa[ii]=F[i];ii++;i++;}            
        else {bb[jj]=F[i];jj++;i++;}            
    }        
    for(i=0;i<(ii-1);i++)            
    { for(j=i;j<ii;j++)        
    {            
        if(aa[i]>aa[j])                
        {                
            temp=aa[i];                
            aa[i]=aa[j];                
            aa[j]=temp;}            
    }        
    }        
    for(i=0;i<(jj-1);i++)            
    {            
        for(j=i;j<jj;j++)                
        { if(bb[i]>bb[j])            
        {temp=bb[i];            
        bb[i]=bb[j];            
        bb[j]=temp;}            
        }            
    }        
    temp=z[0];        
    for(i=0;i<ii;i++)            
    {            
        Y[i]=aa[i]-temp;            
        temp=aa[i];            
        FF[i]=aa[i];}        
    for(j=0;j<jj;j++)            
    {            
        Y[i]=fabs(bb[j]-temp);            
        temp=bb[j];            
        FF[i]=bb[j];            
        i++;            
    }
    
    cout<<"从100＃磁道开始,磁头方向为自外向里"<<endl;        
    cout<<"访问到的磁道号"<<setw(10)<<"移动距离"<<endl;
        a_l=0;
    for(i=0;i<9;i++)            
    {            
        cout<<setw(10)<<FF[i]<<setw(10)<<Y[i]<<endl;            
        a_l+=Y[i];            
    }
    
    cout<<"平均寻道距离:"<<setw(10)<<a_l/9<<endl;}

void main()

{
    int n,i;

   do
   { 
    for(i=0;i<9;i++)
        F[i]=FF[i];
        cout<<"请求访问的磁道号依次为:";
    for(i=0;i<9;i++)
        cout<<F[i]<<"   ";
    cout<<endl;
    cout<<"请选择算法"<<endl;
    cout<<" 1－FCFS "<<endl;
    cout<<" 2－SSTF "<<endl;
    cout<<" 3－SCAN "<<endl;
    cout<<" 4-CSCAN "<<endl;
    cout<<" 0－exit "<<endl;            
    cin>>n;    
    switch(n)        
    {
    case 1:{FCFS();break;}
    case 2:{SSTF();break;}
    case 3:{SCAN();break;}
    case 4:{CSCAN();break;}
    //case 0:exit;        
    }
   }while(n!=0);
}
 

磁盘调度算法

实现磁盘调度算法，模拟磁盘调度。主要实现了先来先服务（FCFS）、最短寻道时间优先（SSTF）、扫描（SCAN）等算法和循环扫描算法（CSCAN）。

Talk is cheap. Show me the code.

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<math.h>
#define MAX_DIASKNUMBER 200 //定义磁盘的最大磁道数
#define TRUE 1//定义真值
#define FALSE 0//定义假值
int disk[MAX_DIASKNUMBER + 1] = { 0 };//存放进程请求磁盘I/O请求时的磁道号,且数字0不做磁道号
int disk_currentnumber = 100;//当前访问的磁盘号，假设当前磁道号为100
int choice = 1;//决定扫描方向（默认为1），1-向增加方向；2-向减小方向
typedef struct Disk_struct//磁盘数据结构
{    
	int disk_nextnumber;//下一个访问的磁盘号
	int disk_distence;//计算移动距离
	int total_distence;//总的移动距离    
	int count;//计算输入了几个磁道号    
	float average_seek_length;//计算平均寻道长度
}DISK;
int COMPARE(const void *a, const void *b)//比较函数，为qsort算法提供比较函数
{    
	return *(int *)a - *(int *)b;
}
void SCANF()//输入算法
{    
	int i = 1;//用作给disk数组的下标    
	char over = 'Y';//用作结束输入标志    
	while (TRUE)    
	{        
		if (over == 'N')        
		{            
			break;//结束        
		}        
		else        
		{            
			printf("请输入被访问的第%d个磁道号：", i);            
			int e = 0;//用于接收输入的磁道号，并防止输入为字符出现的错误            
			scanf_s("%d", &e);//输入进程调用的磁道号                
			int c = 0;            
			while ((c = getchar()) != '\n');//---也要清空缓冲区防止输入多个字符导致循环多次            
			if (e)//----输入字符时为报错，通过用一个变量接收再赋值解决            
			{                
				disk[i] = (int)e;                
				i++;            
			}            
			else            
			{                
				printf("你输入了0或者未按要求输入！请重新输入！\n");                
				continue;            
			}        
		}        
		while (TRUE)        
		{            
			printf("是否继续输入？请选择：（是-Y/y；否-N/n）：");//选择是否继续输入            
			scanf_s("%c", &over, 1);//因为编译器的不同，1表示只读取1个输入字符            
			int c = 0;            
			while ((c = getchar()) != '\n');//---也要清空缓冲区防止输入多个字符导致循环多次            
			if (over == 'y' || over == 'n')//将小写输入转化为大写            
			{                
				over = toupper(over);            
			}            
			if (over == 'Y' || over == 'N')            
			{                
				break;            
			}            
			else            
			{                
				printf("请按要求输入！\n"); //----控制错误输入                
				continue;            
			}
		}    
	}
}
void CHOOSE()
{    
	printf("请输入磁道扫描方向（默认为I/i）：（I/i-向磁道号增加方向；D/d-向磁道号减小方向）\n");    
	char choose = NULL;//控制选择从什么方向开始    
	while (TRUE)    
	{        
		if (choose == 'I' || choose == 'D')        
		{            
			break;        
		}        
		scanf_s("%c", &choose, 1);        
		int c = 0;        
		while ((c = getchar()) != '\n');//---也要清空缓冲区防止输入多个字符导致循环多次        
		while (TRUE)        
		{            
			if (choose == 'i' || choose == 'd')            
			{                
				choose = toupper(choose);            
			}            
			if (choose == 'D')            
			{                
				choice = 0;                
				break;            
			}            
			else if (choose == 'I')//全局变量choice以默认为1            
			{                
				break;            
			}            
			else            
			{                
				printf("请按要求输入！\n");                
				break;            
			}        
		}    
	}
}
void SEARCH(int *m, int *p)//寻找第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置
{    
	for (int j = 0; j <= MAX_DIASKNUMBER; j++)    
	{        
		if (!disk[j])//求排序后的第一个磁道号在数组中的位置        
		{            
			(*m)++;        
		}        
		if (disk[j] == disk_currentnumber)//求最初的磁头所在的磁道号在数组中的位置        
		{            
			(*p) = j;        
		}    
	}
}
void FCFS()
{    
	printf("FCFS算法：\n");    
	DISK disks = { 0,0,0,0,0 };//定义并初始化    
	for (int k = 0; k < MAX_DIASKNUMBER + 1; k++)//初始化disk数组    
	{        
		disk[k] = 0;    
	}    
	disk_currentnumber = 100;//当前访问的磁盘号，假设当前磁道号为100    
	SCANF();//输入进程提出请求的磁道号    
	//--FCFS核心算法    
	int i = 1;//用作disk数组的下标    
	for (i = 1; disk[i] != 0; i++)    
	{        
		disks.disk_nextnumber = disk[i];        
		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);        
		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);        
		disks.disk_distence = abs(disk_currentnumber - disk[i]);//有可能相减为负数，用abs化为正数        
		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);        
		disks.total_distence += disks.disk_distence;        
		printf("总移动距离：%18d\n", disks.total_distence);        
		disk_currentnumber = disk[i];    
	}    
	//--FCFS核心算法    
	disks.count = --i;//计算输入了几个磁道号    
	disks.average_seek_length = (float)disks.total_distence / disks.count;//求平均寻道长度，为避免丢失精度使用强制类型转换为float型    
	printf("平均寻道长度为：%15.2f\n", disks.average_seek_length);//输出保留小数点后2位小数
}
void SSTF()
{    
	printf("SSTF算法：\n");    
	DISK disks = { 0,0,0,0,0 };//定义并初始化    
	for (int k = 0; k < MAX_DIASKNUMBER + 1; k++)//初始化disk数组    
	{        
		disk[k] = 0;    
	}    
	disk_currentnumber = 100;//当前访问的磁盘号，假设当前磁道号为100    
	SCANF();//输入进程提出请求的磁道号    
	disk[0] = disk_currentnumber;//把disk[0]存储为最初的磁头所在的磁道号，为后续排序和求访问的磁道和当前磁头所在的磁道距离提供方便    
	qsort(disk, MAX_DIASKNUMBER + 1, sizeof(disk[0]), COMPARE);//排序    
	int m = 0, p = 0;//m，p分别用作求第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置    
	SEARCH(&m, &p);//搜索m，p    
	disks.count = MAX_DIASKNUMBER - m;//计算共输入了多少个磁道号    
	//--SSTF核心算法    
	while (TRUE)    
	{        
		if (m == 200)        
		{            
			break;        
		}        
		if (disk[p - 1] != 0&&((disk[p] - disk[p - 1]) < (disk[p + 1] - disk[p])))//判断从当前磁道的哪头开始        
		{            
			disks.disk_nextnumber = disk[p - 1];            
			printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
			printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
			disks.disk_distence = abs(disk_currentnumber - disk[p - 1]);//有可能相减为负数，用abs化为正数            
			printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
			disks.total_distence += disks.disk_distence;            
			printf("总移动距离：%18d\n", disks.total_distence);            
			disk_currentnumber = disk[p - 1];            
			disk[p] = 0;            
			qsort(disk, MAX_DIASKNUMBER + 1, sizeof(disk[0]), COMPARE);//排序            
			m = 0, p = 0;//m，p分别用作求第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置            
			SEARCH(&m, &p);//搜索m，p        
		}        
		else        
		{            
			disks.disk_nextnumber = disk[p + 1];            
			printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
			printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
			disks.disk_distence = abs(disk_currentnumber - disk[p + 1]);//有可能相减为负数，用abs化为正数            
			printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
			disks.total_distence += disks.disk_distence;            
			printf("总移动距离：%18d\n", disks.total_distence);            
			disk_currentnumber = disk[p + 1];            
			disk[p] = 0;            
			qsort(disk, MAX_DIASKNUMBER + 1, sizeof(disk[0]), COMPARE);//排序            
			m = 0, p = 0;//m，p分别用作求第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置            
			SEARCH(&m, &p);//搜索m，p        
		}    
	}    
	//--SSTF核心算法    
	disks.average_seek_length = (float)disks.total_distence / disks.count;//为避免丢失精度，使用强制类型转换为float型    
	printf("平均寻道长度为：%15.2f\n", disks.average_seek_length);//输出保留小数点后2位小数
}
void SCAN()
{    
	printf("SCAN算法：\n");    
	DISK disks = { 0,0,0,0,0 };//定义并初始化    
	for (int k = 0; k < MAX_DIASKNUMBER + 1; k++)//初始化disk数组    
	{        
		disk[k] = 0;    
	}    
	disk_currentnumber = 100;//当前访问的磁盘号，假设当前磁道号为100    
	CHOOSE();    
	SCANF();    
	disk[0] = disk_currentnumber;    
	qsort(disk, MAX_DIASKNUMBER + 1, sizeof(disk[0]), COMPARE);    
	int m = 0, p = 0;//m，p分别用作求第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置    
	SEARCH(&m, &p);//搜索m，p    
	disks.count = MAX_DIASKNUMBER - m;//计算共输入了多少个磁道号    
	//--SCAN核心算法    
	if (choice)    
	{        
		for (int j = p + 1; j <= MAX_DIASKNUMBER; j++)        
		{
            
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}        
            	for (int j = p - 1; disk[j] != 0; j--)        
            	{            
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", 
            		disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", 
            		disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", 
            		disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}    
        }    
        else    
        {
        	for (int j = p - 1; disk[j] != 0; j--)        
            	{
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", 
            		disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}        
            	for (int j = p + 1; j <= MAX_DIASKNUMBER; j++)        
            	{
            
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", 
            		disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}    
       }    
       //--SCAN核心算法    
       disks.average_seek_length = (float)disks.total_distence / disks.count;//为避免丢失精度，使用强制类型转换为float型    
       printf("平均寻道长度为：%15.2f\n", disks.average_seek_length);//输出保留小数点后2位小数
}
void CSCAN()
{    
	printf("CSCAN算法：\n");    
	DISK disks = { 0,0,0,0,0 };//定义并初始化    
	for (int k = 0; k < MAX_DIASKNUMBER + 1; k++)//初始化disk数组    
	{        
		disk[k] = 0;    
	}    
	disk_currentnumber = 100;//当前访问的磁盘号，假设当前磁道号为100    
	CHOOSE();    
	SCANF();    
	disk[0] = disk_currentnumber;    
	qsort(disk, MAX_DIASKNUMBER + 1, sizeof(disk[0]), COMPARE);    
	int m = 0, p = 0;//m，p分别用作求第一个磁道号在数组中的位置和求最初的磁头所在的磁道号在数组中的位置    
	SEARCH(&m, &p);//搜索m，p    
	disks.count = MAX_DIASKNUMBER - m;//计算共输入了多少个磁道号    
	//--CSCAN核心算法    
	if (choice)    
	{        
		for (int j = p + 1; j <= MAX_DIASKNUMBER; j++)        
		{
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            disk_currentnumber = disk[j];        
            	}        
            	for (int j = m; disk[j] != disk[p]; j++)        
            	{            
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            
            		printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}    
         }    
         else    
         {        
         	for (int j = p - 1; disk[j] != 0; j--)        
         	{            
         		disks.disk_nextnumber = disk[j];            
         		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
         		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
         		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
         		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
         		disks.total_distence += disks.disk_distence;            
         		printf("总移动距离：%18d\n", disks.total_distence);            
         		disk_currentnumber = disk[j];        
         	}        
         	for (int j = MAX_DIASKNUMBER; disk[j] != disk[p]; j--)        
         	{
            		disks.disk_nextnumber = disk[j];            
            		printf("当前磁头所在磁道：%12d\n", disk_currentnumber);            
            		printf("被访问的下一个磁道号：%8d\n", disks.disk_nextnumber);            
            		disks.disk_distence = abs(disk_currentnumber - disk[j]);//有可能相减为负数，用abs化为正数            
            		printf("移动距离（磁道数）：%10d\n", disks.disk_distence);            
            		disks.total_distence += disks.disk_distence;            printf("总移动距离：%18d\n", disks.total_distence);            
            		disk_currentnumber = disk[j];        
            	}    
         }    
         //--CSCAN核心算法    
         disks.average_seek_length = (float)disks.total_distence / disks.count;//为避免丢失精度，使用强制类型转换为float型    
         printf("平均寻道长度为：%15.2f\n", disks.average_seek_length);//输出保留小数点后2位小数
}
int main()
{    
	int flag = 0;//flag作为判定标志    
	while (TRUE)    
	{        
		if (!flag)//第一次选择        
		{            
			printf("请选择退出或希望使用的磁盘调度算法：（0-退出；1-FCFS；2-SSTF；3-SCAN；4-CSCAN）\n");            
			int choose = -1;//用choose来选择相应的算法            
			scanf_s("%d", &choose);//-----若输入字符会无限循环，清空缓冲区解决            
			int c = 0;//用于接收缓冲区内容            
			while ((c = getchar()) != '\n' && c != EOF);//----清空缓冲区以后输入字符才可以不无限循环            
			switch (choose)//根据选择调用算法            
			{            
				case 0:system("pause"); return 0; break;            
				case 1:FCFS(); flag = 1; break;            
				case 2:SSTF(); flag = 1; break;            
				case 3:SCAN(); flag = 1; break;            
				case 4:CSCAN(); flag = 1; break;            
				default:printf("请按要求输入！\n"); break;            
			}        
		}        
		else//后续选择        
		{            
			printf("退出或者继续调用磁盘调度算法？请选择：（0-退出；1-FCFS；2-SSTF；3-SCAN；4-CSCAN）\n");            
			int choose = -1;//用choose来选择相应的算法            
			scanf_s("%d", &choose);            
			int c = 0;//用于接收缓冲区内容            
			while ((c = getchar()) != '\n' && c != EOF);//----清空缓冲区以后输入字符才可以不无限循环            
			switch (choose)//根据选择调用算法            
			{            
				case 0:system("pause"); return 0; break;            
				case 1:FCFS(); break;            
				case 2:SSTF(); break;            
				case 3:SCAN(); break;            
				case 4:CSCAN(); break;            
				default:printf("请按要求输入！\n"); break;            
			}        
		}    
	}
}

测试结果

0.

1.

2.

3.

4.