精华内容
下载资源
问答
  • 磁盘寻道算法 电梯调度算法 C++实现 #include<iostream> using namespace std; #include<vector> #include<algorithm> compute(vector<int> v,int x,int d) { double w=1; sort(v.begin()...

    磁盘寻道算法 电梯调度算法 C++实现

    #include<iostream>
    using namespace std;
    #include<vector>
    #include<algorithm>
    compute(vector<int> v,int x,int d)
    {
        double w=1;
        sort(v.begin(),v.end());
        if(d==1){
            cout<<endl<<"    磁头从"<<x<<"磁道开始,向磁道号"<<endl;
            cout<<"            增加方向访问"<<endl;
            cout<<"    被访问的           移动距离    "<<endl;
            cout<<"  下一个磁道号        (磁道数)   "<<endl;
            int i;
            for(i=0;i<v.size();i++){
                if(x<v[i])
                    break;
            }
            int g=i,s=0;;
            int m=v[i]-x,x1=x;
            for(int j=0;j<v.size();j++){
                m=abs(v[i]-x1);
                cout<<"      "<<v[i]<<"                 "<<m<<endl;
                w+=m;
                x1=v[i];
                if(i==v.size()-1){
                    i=g;s=1;
                }
                if(s==0){
                    i++;
                }
                else{
                    i--;
                }
            }
        }
        else{
            cout<<endl<<"    磁头从"<<x<<"磁道开始,向磁道号"<<endl;
            cout<<"           减少方向访问"<<endl;
            cout<<"    被访问的           移动距离    "<<endl;
            cout<<"  下一个磁道号        (磁道数)   "<<endl;
            int i;
            for(i=0;i<v.size();i++){
                if(x<v[i+1])
                    break;
            }
            int g=i,s=0;;
            int m=v[i]-x,x1=x;
            for(int j=0;j<v.size();j++){
                m=abs(v[i]-x1);
                cout<<"      "<<v[i]<<"                 "<<m<<endl;
                w+=m;
                x1=v[i];
                if(i==0){
                    i=g;s=1;
                }
                if(s==0){
                    i--;
                }
                else{
                    i++;
                }
            }
        }
        cout<<"   平均寻道长度:"<<w/v.size()<<endl;
    }
    int main()
    {
        vector<int> v;
        int n,x,d;
        cout<<"请输入进程的数量:"<<endl;
        cin>>n;
        cout<<"请输入各进程所在的磁道号(1-200):"<<endl;
        for(int i=0;i<n;i++){
            int o;cin>>o;
            v.push_back(o);
        }
        cout<<"请输入当前磁头所在磁道(1-200):"<<endl;
        cin>>x;
        cout<<"请输入当前磁头的寻道范方向:"<<endl;
        cout<<"0-----磁道号递减方向"<<endl;
        cout<<"1-----磁道号递增方向"<<endl;
        cin>>d;
        compute(v,x,d);
    }
    /*
    9
    160 90 150 58 55 184 18 39 38
    100
    1
    
    9
    150 160 184 90 58 55 39 38 18
    100
    0
    
    */
    
    

    在这里插入图片描述

    展开全文
  • 操作系统模拟之磁盘寻道算法。 文件共1份,代码如下: import math import random import copy def alo_fcfs(): print("您选择了FCFS算法,执行结果如下:") print("当前磁道号 下一磁道号 绝对差") print('{:...

    操作系统模拟之磁盘寻道算法。
    文件共1份,代码如下:

    import math
    import random
    import copy
    
    
    def alo_fcfs():
        print("您选择了FCFS算法,执行结果如下:")
        print("当前磁道号 下一磁道号 绝对差")
        print('{:6d}{:10d}{:8d}'.format(start_numer, disk_queue[0], abs(start_numer - disk_queue[0])))
        sum_distance = abs(start_numer - disk_queue[0])
        for i in range(disk_queue_length - 1):
            sum_distance = sum_distance + abs(disk_queue[i] - disk_queue[i + 1])
            print('{:6d}{:10d}{:8d}'.format(disk_queue[i], disk_queue[i + 1], abs(disk_queue[i] - disk_queue[i + 1])))
        print('{:6d}       {}    {}'.format(disk_queue[i], "None", "None"))
        print('寻道序列总长{:d},FCFS算法的平均寻道长度为{:.2f}'.format(sum_distance, sum_distance / (disk_queue_length + 1)))
    
    
    def alo_sstf():
        print("您选择了SSTF算法,执行结果如下:")
        print("当前磁道号 下一磁道号 绝对差")
        sum_distance = 0
        last_number = start_numer
        temp_queue = copy.deepcopy(disk_queue)
        while len(temp_queue) > 0:
            index = 0
            min_diff = 0x3f3f3f3f
            for i in range(len(temp_queue)):
                if abs(temp_queue[i] - last_number) < min_diff:
                    index = i
                    min_diff = abs(temp_queue[i] - last_number)
            print('{:6d}{:10d}{:8d}'.format(last_number, temp_queue[index], min_diff))
            last_number = temp_queue[index]
            sum_distance = sum_distance + min_diff
            temp_queue.pop(index)
        print('{:6d}       {}    {}'.format(last_number, "None", "None"))
        print('寻道序列总长{:d},SSTF算法的平均寻道长度为{:.2f}'.format(sum_distance, sum_distance / (disk_queue_length + 1)))
    
    
    def cal(temp_queue, start_number, index, left1, left2, right1, right2, step1, step2):
        last_number = start_number
        print('{:6d}{:10d}{:8d}'.format(last_number, temp_queue[index], abs(last_number - temp_queue[index])))
        sum_distance = abs(last_number - temp_queue[index])
        last_number = temp_queue[index]
        for j in range(left1, right1, step1):
            print('{:6d}{:10d}{:8d}'.format(last_number, temp_queue[j], abs(last_number - temp_queue[j])))
            sum_distance = sum_distance + abs(last_number - temp_queue[j])
            last_number = temp_queue[j]
        for j in range(left2, right2, step2):
            print('{:6d}{:10d}{:8d}'.format(last_number, temp_queue[j], abs(last_number - temp_queue[j])))
            sum_distance = sum_distance + abs(last_number - temp_queue[j])
            last_number = temp_queue[j]
        print('{:6d}       {}    {}'.format(last_number, "None", "None"))
        print('寻道序列总长{:d},FCFS算法的平均寻道长度为{:.2f}'.format(sum_distance, sum_distance / (disk_queue_length + 1)))
    
    
    def alo_scan():
        print("您选择了SCAN算法,执行结果如下:")
        print("请继续选择当前磁头运动方向")
        print("由低到高请输入1")
        print("由高到低请输入2")
        last_number = start_numer
        direction_choice = int(input())
        temp_queue = copy.deepcopy(disk_queue)
        temp_queue.sort()
        print()
        print("当前磁道号 下一磁道号 绝对差")
        if direction_choice == 1:
            for j in temp_queue:
                if j > start_numer:
                    index = temp_queue.index(j)
                    break
            cal(temp_queue, start_numer, index, index + 1, index - 1, disk_queue_length, -1, 1, -1)
        elif direction_choice == 2:
            for j in range(disk_queue_length - 1, -1, -1):
                if temp_queue[j] < start_numer:
                    index = j
                    break
            cal(temp_queue, start_numer, index, index - 1, index + 1, -1, disk_queue_length, -1, 1)
    
    
    def alo_cscan():
        print("您选择了CSCAN算法,执行结果如下:")
        print("请继续选择当前磁头运动方向")
        print("由低到高请输入1")
        print("由高到低请输入2")
        last_number = start_numer
        direction_choice = int(input())
        temp_queue = copy.deepcopy(disk_queue)
        temp_queue.sort()
        print()
        print("当前磁道号 下一磁道号 绝对差")
        if direction_choice == 1:
            for j in temp_queue:
                if j > start_numer:
                    index = temp_queue.index(j)
                    break
            cal(temp_queue, start_numer, index, index + 1, 0, disk_queue_length, index, 1, 1)
        elif direction_choice == 2:
            for j in range(disk_queue_length - 1, -1, -1):
                if temp_queue[j] < start_numer:
                    index = j
                    break
            cal(temp_queue, start_numer, index, index - 1, disk_queue_length - 1, -1, index, -1, -1)
    
    
    if __name__ == "__main__":
        print("欢迎进入操作系统演示之磁盘寻道算法")
        print("现在开始数据初始化")
        print("请输入磁盘寻道序列长度(10-20,含端点):")
        disk_queue_length = int(input())
        if 10 <= disk_queue_length <= 20:
            print("输入成功!")
        else:
            print("您输入的磁盘寻道序列长度超出给定范围,请重新输入10-20(含端点)的数字:")
            print("请输入磁盘寻道序列长度(10-20,含端点):")
            disk_queue_length = int(input())
    
        disk_queue = []
        for k in range(disk_queue_length):
            disk_queue.append(random.randint(0, 200))
        start_numer = random.randint(0, 200)
        print()
        print('生成的磁盘寻道序列为:{}'.format(disk_queue))
    
        while True:
            print()
            print("请选择要执行的磁盘寻道算法:")
            print("选择FCFS请输入1")
            print("选择SSTF请输入2")
            print("选择SCAN请输入3")
            print("选择CSCAN请输入4")
            menu_choice = int(input())
            if menu_choice == 1:
                alo_fcfs()
            elif menu_choice == 2:
                alo_sstf()
            elif menu_choice == 3:
                alo_scan()
            elif menu_choice == 4:
                alo_cscan()
            else:
                print("您选择的不在范围内,请重新输入")
                print()
                continue
            print()
            print("继续尝试其他算法请输入1")
            print("更新数据请输入2")
            print("结束程序请输入3")
            end_choice = int(input())
            if end_choice == 1:
                continue
            elif end_choice == 2:
                print("现在开始更新数据")
                print("请输入更新的磁盘寻道序列长度(10-20,含端点):")
                disk_queue_length = int(input())
                if 10 <= disk_queue_length <= 20:
                    print("更新成功!")
                else:
                    print("您输入的磁盘寻道序列长度超出给定范围,请重新输入10-20(含端点)的数字:")
                    print("请输入磁盘寻道序列长度(10-20,含端点):")
                    disk_queue_length = int(input())
                disk_queue = []
                for k in range(disk_queue_length):
                    disk_queue.append(random.randint(0, 200))
                print()
                print('更新的磁盘寻道序列为:{}'.format(disk_queue))
                start_numer = random.randint(0, 200)
            else:
                print("程序退出成功!")
                break
    
    
    展开全文
  • 操作系统课程设计,磁盘寻道算法。做了扫描和循环扫描算法。分别用数组和链表方式进行了测试。并比较了时间效率。
  • 操作系统中的,4种寻道算法。FCFS(先来先服务) SSTF(最短寻道时间) SCAN(扫描算法) CSCAN(循环扫描法)
  • #include <stdio.h> #include <stdlib.h> int tracks[200];//track number void Init(int start,int num);//initialize track sequence void FCFS(int start,int num);//First come first serve algori...
    #include <stdio.h>
    #include <stdlib.h>
    int tracks[200];//track number
    
    void Init(int start,int num);//initialize track sequence
    void FCFS(int start,int num);//First come first serve algorithm
    void SSTF(int start,int num);//Shortest seek time first algorithm
    
    void Init(int start,int num)
    {
    	int i;
    	printf("----------Input Track Number---------\n");
    	for(i=0;i<num;i++)
    	{
    		printf("Please enter track number %d : ",i+1);
    		scanf("%d",&tracks[i]);
    	}
    
    }
    void FCFS(int start,int num)
    {
    	double sum=0;
    	int temp,i;
    	printf("==========================\n");
    	printf("Starting from track number %d\n",start);
    	printf("Next track number:\t seek length:\n");
    	for(i=0;i<num;i++)
    	{
    		temp=abs(start-tracks[i]);
    		printf("%d\t\t\t %d\n",tracks[i],temp);
    		sum+=temp;
    		start=tracks[i];
    	}
    	printf("Average seek length:%.3lf\n",sum/num);
    	printf("==========================\n");
    }
    void SSTF(int start,int num)
    {
    	int i,j,temp,min,mint;
    	bool table[100];
    	double sum=0;
    	for(i=0;i<num;i++)
    	{
    		table[i]=0;
    	}
    	printf("==========================\n");
    	printf("Starting from track number %d\n",start);
    	printf("Next track number:\t seek length:\n");
    	for(i=0;i<num;i++)
    	{
    		min=-1;
    		for(j=0;j<num;j++)
    		{
    			if(!table[j])
    			{
    				temp=abs(start-tracks[j]);
    				if(min==-1||min>temp)
    				{
    					min=temp;
    					mint=j;
    				}
    			}
    		}
    		printf("%d\t\t\t %d\n",tracks[mint],min);
    		start=tracks[mint];
    		table[mint]=1;
    		sum+=min;
    	}
    	printf("Average seek length:%.3lf\n",sum/num);
    	printf("==========================\n");
    }
    
    
    
    int main()
    {
    	int start;//Initial track number
    	int num;//visit times
    	int choose;
    	printf("\t\t\t Disk Scheduling Algorithms\n");
    
    
    	do
    	{
    		printf("Please enter the initial track number(0~200):");
    		scanf("%d",&start);
    	}while(start<0||start>200);
    	do
    	{
    		printf("Please enter the number of disk accesses(1~10):");
    		scanf("%d",&num);
    	}while(num<1||num>10);
    	
    	Init(start,num);
    	do
    	{
    		do
    		{
    			printf("1.FCFS\n");
    			printf("2.SSTF\n");
    			printf("3.exit\n");
    			printf("Please select:");
    			scanf("%d",&choose);
    		}while(choose<1||choose>5);
    		switch(choose)
    		{
    			case 1:
    				FCFS(start,num);
    				break;
    			case 2:
    				SSTF(start,num);
    				break;
    			case 3: exit(0);
    		}
    	}while(choose!=5);
    	return 0;
    }
    
    
    
    
    展开全文
  • printf("请选择:\n1、SSTF(最短寻道优先算法)\n2、CSCAN(循环扫描算法)\n"); printf("3、SCAN(扫描算法)\n4、重新产生一组新的序列\n5、结束\n\n"); char c; while(c=getchar(),c!='5'){ switch(c){ ...



    #include<stdio.h>
    #include<time.h>
    #include<stdlib.h>
    #include<string.h>
    #include<malloc.h>
    #include<math.h>
    #define MAX 100 //磁道范围 
    #define N 20   //序列数目 
    
    int list[MAX];  //存放随机产生的序列 
    int visit[MAX]; //标记数组 
    int location;//初始磁头位置  
    int closedistant; //保存其他磁道与当前磁头所在磁道的最短距离 
    
    //按磁道从小到大排序 
    void sort()
    {
    	int i;
    	int j;
    	int t;
    	for(i=0;i<N-1;i++){
    		for(j=i+1;j<N;j++){
    			if(list[j]<list[i]){
    				t=list[i];
    				list[i]=list[j];
    				list[j]=t;
    			}
    		}
    	}
    }
    
    //随机产生磁头初始位置和访问序列 
    void CreateList()
    {
        int j;                
    	int i;
    	location=rand()%MAX+1;//随机产生初始磁头位置 
    	printf("当前磁头位置:%d\n\n",location);
    	printf("请求访问的磁道号序列:\n");
    	for(i=0;i<N;i++){           //随机产生请求磁道号序列 
    		list[i]=rand()%MAX+1;
    		printf("%d ",list[i]);
    	}
    	printf("\n\n");
    }
    
    //最短寻道优先算法
    void SSTF() 
    {
    	int i;
    	int j;
    	int k;//记录最近的磁道号 
    	int loca;
    	int move;
    	int shortest;  //记录最短的距离 
    	int after[MAX];
    	memset(visit,1,sizeof(visit));
    	move=0;
    	loca=location;
    	for(i=0;i<N;i++){
    		shortest=MAX;
    		for(j=0;j<N;j++){//有更近磁道更新 
    			if(visit[j]){
    				if(fabs(loca-list[j])<shortest){
    					shortest=fabs(loca-list[j]);
    					k=j;
    				}
    			}
    		}
    		move=move+shortest;  //记录移动的距离 
    		loca=list[k];  //跟踪当前磁头所在位置 
    		visit[k]=0;  //标记已访问 
    		after[i]=list[k];  //记录路径 
    	}
    	printf("\n采用SSTF算法后的寻道序列为:\n");
    	for(i=0;i<N-1;i++){
    		printf("%d->",after[i]);
    	} 
    	printf("%d\n\n",after[i]);
    	printf("所有进程运行后磁头运行的总磁道数为:%d\n\n",move);
    	printf("平均寻道时间为:%.2lf\n\n",move*1.0/N);
    	printf("\n-------------------------------------------------------\n\n"); 
    }
    
    //循环扫描算法
    void CSCAN() 
    {
        int i;
        int j;
        int move;
        int loca;
        int after[MAX];
        i=0;
        loca=location;
        for(i=0;i<N;i++){      //找到磁头在序列中的位置 
        	if(list[i]>=loca){
        		break;
        	}
        }
        move=0;
        for(j=0;j<N;i++,j++){
        	if(i==N){         //形成头尾相连 
        		i=0;
        	}
    	    move=move+fabs(list[i]-loca);  //记录移动的距离 
    		loca=list[i];    //记录当前磁头所在位置 
        	after[j]=list[i];  //记录路径 
        }
        printf("\n本算法规定磁头自里向外移动\n\n");
        printf("采用CSCAN算法后的寻道序列为:\n");
    	for(i=0;i<N-1;i++){
    		printf("%d->",after[i]);
    	} 
    	printf("%d\n\n",after[i]);
    	printf("所有进程运行后磁头运行的总磁道数为:%d\n\n",move);
    	printf("平均寻道时间为:%.2lf\n\n",move*1.0/N);
    	printf("\n-------------------------------------------------------\n\n");
    }
    
    //扫描算法
    void SCAN() 
    {
        int i;
        int j;
        int k;
        int move;
        int loca;
        int after[MAX];
        loca=location;
        i=0;
        for(i=0;i<N;i++){   //找到当前磁头所在位置 
        	if(list[i]>=loca){
        		break;
        	}
        }
        j=i-1;
        k=0;
        move=0;
        while(i<N){//先自里向外 
    	    move=move+fabs(list[i]-loca);//记录移动的距离 
    		loca=list[i]; //记录当前磁头位置 
        	after[k++]=list[i];//记录路径 
        	i++;
        }
        while(j>=0){//后自外向里 `
        	move=move+fabs(list[j]-loca);//记录移动的距离
    		loca=list[j]; //记录当前磁头位置 
        	after[k++]=list[j];//记录路径 
        	j--;
        }
        printf("\n本算法规定磁头初始方向为自低磁道向高磁道\n\n");
        printf("采用SCAN算法后的寻道序列为:\n");
    	for(i=0;i<N-1;i++){
    		printf("%d->",after[i]);
    	} 
    	printf("%d\n\n",after[i]);
    	printf("所有进程运行后磁头运行的总磁道数为:%d\n\n",move);
    	printf("平均寻道时间为:%.2lf\n\n",move*1.0/N);
    	printf("\n-------------------------------------------------------\n\n");
    }
    
    void Start()
    {
    	sort();
    	printf("请选择:\n1、SSTF(最短寻道优先算法)\n2、CSCAN(循环扫描算法)\n");
        printf("3、SCAN(扫描算法)\n4、重新产生一组新的序列\n5、结束\n\n");
    	char c;
    	while(c=getchar(),c!='5'){
    	    switch(c){
    		    case '1':SSTF();break;
    		    case '2':CSCAN();break;
    		    case '3':SCAN();break;
    		    case '4':CreateList();sort();break;
    		    default:break; 
    	    }
    	}
    }
    
    int main()
    {
    	srand((unsigned)time(NULL));
    	CreateList();
        Start();
    	return 0;
    }

    展开全文
  • 磁盘寻道调度算法

    千次阅读 2020-03-31 11:03:03
    磁盘调度在多道程序设计的计算机系统中,各个进程可能会不断提出不同的对磁盘进行读 / 写操作的请求。...最短寻道时间优先算法(SSTF), 扫描算法(SCAN), 循环扫描算法(CSCAN)   例: 假定某磁盘共有 ...
  • 操作系统之磁盘寻道调度算法

    千次阅读 2017-03-29 19:50:38
    磁盘调度在多道程序设计的计算机系统中,各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。...最短寻道时间优先算法(SSTF), 扫描算法(SCAN), 循环扫描算法(CSCAN)   例:假定某磁盘
  • 自己写的磁盘调度算法,通俗易懂,其中有先来先服务调度算法,最短寻道时间调度算法、电梯调度算法
  • 本代码包含银行家算法 处理机调度 磁盘寻道三个实验,解压后将所有文件导入Eclipse运行即可,注意:解压后将所有文件导入。
  • 磁盘调度算法寻道问题

    万次阅读 2016-09-26 15:59:01
    最短寻道时间优先算法(SSTF) 扫描算法(SCAN) 循环扫描算法(CSCAN) 先来先服务算法(First Come First Service)FCFS算法根据进程请求访问磁盘的先后顺序进行调度,是一种最简单的调度算法。 例1:某一磁盘...
  • 一、设计目的: 加深对请求磁盘调度管理实现原理的理解,掌握磁盘调度算法中的扫描寻道算法。二、设计内容通过编程实现磁盘调度中扫描寻道算法。设定开始磁道号寻道范围,依据起始扫描磁道号和最大磁道号数,随机...
  • 若干个等待访问磁盘者依次要访问的柱面编号为:80,40,74,14,60,31,61,假设每移动一个...(2)若采用最短寻道时间优先算法调度,求移动臂的移动次序和所花费的寻找时间。 解: (1)SCAN算法调度 下一...
  • 磁盘调度算法(先来先服务。最短寻道时间算法) 操作系统课程设计
  • 磁盘寻道时间

    千次阅读 2016-07-14 16:26:58
    寻道(Track)时,移动一个柱面需6ms,按下列算法计算所需寻道时间(柱面移动顺序及所需时间,总寻道时间;忽略到达指定柱面后所需寻道时间)。(上海交通大学1999年试题) ① 先来先服务。 ② 下一个最邻近柱面。 ...
  • 原创最近操作系统实习,敲了实现最短寻道优先(SSTF)——磁盘调度管理的代码。题目阐述如下:设计五:磁盘调度...选择磁盘调度算法,显示该算法的磁道访问顺序,计算出移动的磁道总数和平均寻道总数。常用的磁盘调...
  • 实现磁盘调度的一些功能,如:先来先服务算法(FCFS),最短寻道时间优先算法(SSTF),扫描算法(SCAN),循环扫描算法(CSCAN),N步扫描算法(NStepScan)
  • 个人资料整理 仅限学习使用 实验七磁盘调度算法 目 录 一实验目的 加深对磁盘的工作原理和调度效率的理解掌握各种磁盘调度算法模拟实现一种磁盘调度算法 等 b5E2RGbCAP 二实验属性 该实验为设计性实验 个人资料整理 ...
  •  掌握磁盘调度算法,如先来先服务(firstcome first served,FCFS)调度算法、最短寻道时间优先(shortest seek timefirst,SSTF)调度算法、扫描(SCAN)调度算法、循环扫描(C-SCAN)调度算法。二、 实验内容设计...
  • 最短寻道时间优先(SSTF)和扫描(SCAN)算法。理解各调度算法的工作原理 对给出的任意的磁盘请求序列、计算平均寻道长度;要求可定制磁盘请求序列长度、磁头起始位置、磁头移动方向。 测试:假设磁盘访问序列:98,...
  • 磁盘寻道调度问题

    千次阅读 2018-08-19 11:17:26
    最短寻道时间优先算法(**FSST**-shorest seek time first) 3. 扫描算法(SCAN)也称为电梯调度 4. 循环扫描算法(CSCAN) 先来先服务算法: 按照请求访问磁盘的先后顺序进行调度,最简单的...
  • 操作系统实验之磁盘调度算法模拟(最短寻道时间优先SSTF 和 扫描算法SCAN) 最短寻道时间优先SSTF 要求每次访问的磁道与当前磁头所在的磁道距离最近、 也就是每次访问距离磁头最近的磁道 扫描算法SCAN 由里向外地...
  • } } } } 磁盘调度算法先来先服务 / 最短寻道优先 #include<stdio.h> #include<stdlib.h> #include<math.h> void FCFS(int a[],int m,int now;// 先来先服务 void SSTF(int a[],int n,int now;// 最短寻道时间优先 ...
  • 磁盘调度算法sstf算法 辅助存储和磁盘调度算法 (Secondary Storage and Disk Scheduling Algorithms) Secondary storage devices are those devices whose memory is non volatile, meaning, the stored data will ...
  • 磁盘调度算法主要包括三种算法:先来先服务、最短寻道,电梯调度。程序为java代码,编写,调试,运行都在myeclipse环境下完成,欢迎下载!
  • 基于java图形界面开发出“Stephen的磁盘调度mini模拟器”,实现出先来先服务&最短寻道&扫描算法&循环扫描算法的执行效果。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,463
精华内容 4,185
关键字:

磁盘的寻道算法