精华内容
下载资源
问答
  • 磁盘调度算法c语言
    千次阅读
    2020-08-09 21:13:56

    一、实验目的及要求

        通过模拟磁盘调度算法加深对磁盘调度的理解,熟悉磁盘管理系统的设计方法;加深对磁盘访问过程的理解。

    二、实验内容

         编程实现下述磁盘调度算法,并求出每种算法的平均寻道长度,并给出调度顺序;要求在主界面中灵活选择调度算法,要求实现以下磁盘调度算法:

        1.先来先服务FCFS  

        2.最短寻道时间优先SSTF   

        3.扫描算法SCAN   

       4.循环扫描算法CSCAN

    三、程序结构及流程图 

    程序包含一个主函数以及四种调度算法对应的子函数。

    更多相关内容
  • 磁盘调度算法 c语言

    2014-12-11 17:24:39
    先来先服务算法(FCFS) 最短寻道时间优先算法(SSTF) 扫描算法(SCAN) 循环扫描算法(CSCAN) N步扫描算法(NStepScan)
  • 操作系统上机实验,要求使用C语言实现FCFS/SSTF/SCAN/CSCAN四种磁盘调度算法 本程序界面清晰,运行结果与教材一致,可以修改最大磁道号和初始磁道号(SSTF,SCAN,CSCAN算法中从哪个磁道号开始搜索),交互性较好 欢迎...
  • 假设要求从系统中输入N个需访问的柱面号,当前磁头的移动方向由键盘输入(1代表磁头从外往内移动,-1代表磁头由内往外移动),当前磁头刚完成访问序号为M的柱面,请编程输出采用电梯调度算法得到的柱面访问序列号,...
  • 磁盘调度算法C语言

    千次阅读 2019-12-31 23:23:27
    磁盘调度算法 磁盘调度主要应用于多道批处理系统中,以满足多个进程对磁盘读/写的请求。常用的磁盘调度算法有以下四种: 1. 先来先服务FCFS 此算法的优点是公平、简单,且每个进程 的请求都能依次得到处理,不会出现...

    磁盘调度算法

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

    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

    在这里插入图片描述

    展开全文
  • 磁盘调度 算法 c语言

    2010-11-26 22:58:21
    先来先服务 最短寻道时间优先 扫描算法 循环扫描算法 N-Step-SCAN FSCAN调度算法 新出现的所有请求磁盘I/O的进程
  • 磁盘调度算法通常有FCFS、SSTF、SCAN、CSAN这四种算法,以下是这种四种方法的总和: #include<iostream> using namespace std; #include<math.h> #include<iomanip> int FF[10]={55,58,39,18,...

    磁盘调度算法通常有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);
    }
     

    展开全文
  • 本文档是计算机操作系统实验,用FSFC算法和SCAN算法实现了磁盘调度算法
  • 磁盘调度算法 实现磁盘调度算法,模拟磁盘调度。主要实现了先来先服务(FCFS)、最短寻道时间优先(SSTF)、扫描(SCAN)等算法和循环扫描算法(CSCAN)。 Talk is cheap. Show me the code. #include<stdio.h>...

    磁盘调度算法

    实现磁盘调度算法,模拟磁盘调度。主要实现了先来先服务(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.

    在这里插入图片描述

    展开全文
  • 1.了解UNIX的命令及使用格式,熟悉UNIX/LINUX...2.设计一个磁盘工作区,并使用先来先服务算法(FCFS)、最短寻道时间优先算法(SSTF)、扫描算法(SCAN)和循环扫描算法(C-SCAN)计算磁头移动的总磁道数。 平均磁道数
  • 磁盘调度算法C语言实现

    千次阅读 2018-05-26 23:12:33
    扫描调度(SCAN)算法。该算法不仅考虑到欲访问的磁道与当前磁道间的距离,更优先考虑的是磁头当前的移动方向。例如,当磁头正在自里向外移动时,SCAN算法所考虑的下一个访问对象,应是其欲访问的磁道,既在当前磁道...
  • #include <stdio.h> #include <...int* Bubble(int up[],int n)//冒泡排序算法 { int i,j; int temp=0; for(i=0;i<=n;++i) { for(j=i;j<=n;++j) { if(up[i]>up[j]) { temp=u...
  • 磁盘调度算法 1。实现三种算法: 1。先来先服务 2。最短寻道优先(可自己假设当前磁头的位置) 3。电梯算法 2。磁道服务顺序从指定的文本文件(TXT文件)中取出 3。输出: 第一行:磁道的服务顺序 第二行:显示移动...
  • 本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统,从而使磁盘调度算法更加形象化,容易使人理解,使磁盘调度的特点更简单明了,能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及...
  • 磁盘调度算法

    2021-05-24 03:01:49
    *****************************************课题:磁盘调度算法******************************************#include "stdio.h"#include "stdlib.h"void CopyL(int Sour[],int Dist[] ,int x);//数组Sour复制到数组...
  • 假设有 n 个磁道号所组成 的磁道访问序列,给定开始磁道号 m 和磁头移动的方向,正向 或者反向,分别利用不同的磁盘调度算法访问磁道序列,给出 每一次访问的磁头移动距离,计算每种算法的平均寻道长度
  • 操作系统实 验 报 告课程名称操作系统实验实验项目名称磁盘调度算法学号班级姓名专业计算机科学与技术学生所在学院计算机科学与技术学院指导教师初妍实验室名称地点21#428哈尔滨工程大学计算机科学与技术学院第六讲 ...
  • 代码: #include <stdio.h> #include <... //磁盘数 //55 58 39 18 90 160 150 38 184 int request[100]; //请求磁盘序列 int begin; //开始磁盘位置 int kua; //横跨的总数 int k; //每次
  • 实用标准文案 目录 目录 1 1 课程设计目的 1 1.1 编写目的 1 2 课程设计内容 1 2.1 设计...1.1 编写目的 本课程设计的目的是通过磁盘调度算法设计一个磁盘调度模拟系统 从而使磁盘调度算法更加形象化容易使人理解使磁
  • 磁盘调度算法 FCFS 将需要分配的先来先分配。算法实现,直接计算每两个之间磁盘移动的距离。取一个绝对值。 void FCFS(){ cout<<"FCFS: \n"; int pre=100; cout<<"\n从100号磁道开始\n\n"; cout<...
  • (1) 实现的磁盘调度算法有FCFS,SSTF,SCAN,CSCAN和 NStepSCAN算法。 (2) 设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机产生要进行寻道的磁道号序列。 (3) 选择磁盘调度算法,显示该算法的磁道...
  • 操作系统 磁盘调度

    2017-08-21 21:54:35
    操作系统课程设计 磁盘调度
  • 磁盘调度算法设计与实现——C语言

    万次阅读 多人点赞 2018-07-08 10:54:41
    一、设计分析共享设备的典型代表为磁盘,磁盘物理块的地址由柱面号、磁头号、扇区号来指定,完成磁盘某一个物理块的访问要经过三个阶段:寻道时间Ts、旋转延迟时间Tw和读写时间Trw...磁盘调度的原则是公平和高吞吐量...
  • 磁盘调度算法的仿真磁盘调度算法模拟实验目的磁盘是可供多个进程共享的设备,当有多个进程都要求访问磁盘是,应采用一种最佳调度算法,以使各进程对磁盘的平均访问时间最小。目前最成用的磁盘调度算法有先来先服务...
  • 实 验 报 告 题目 C 语言实现调度算法程序设计实验报告 -先来先服务 FCFS 名称 院系 a 班级 完成时间 指导老师 本次实验 成绩 算法原理 设计程序模拟进程的先来先服务 FCFS过程假设有 n 个进程分别 1 n 1 n 在 T , ,...
  • 磁盘调度算法sstf scan cscan C语言实现

    千次阅读 2018-05-24 17:20:55
    #include&lt;stdio.h&gt;#include&lt;time.h&gt;#include&lt;stdlib.h&...//最短寻道优先void scan( int *a,int m,int y );//电梯扫描算法void cscan(int *a,int m ,int ...
  • 磁盘调度算法 相关计算内容 寻找时间Ts 延迟时间Tr:平均延迟时间简单理解就是转半圈的时间 - 传输时间Tt:简单理解转一圈的时间×转的比例 磁盘调度算法 先来先服务(FCFS)算法 最短寻找时间优先(SSTF)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,333
精华内容 3,333
关键字:

磁盘调度算法c语言