精华内容
下载资源
问答
  • Working on a SSTF algorithm using java.util.ComparatorThis is what i have so far:private int nextHeadPosition;public SSTF(int currentHeadPosition) {nextHeadPosition = currentHeadPosition;...

    Working on a SSTF algorithm using java.util.Comparator

    This is what i have so far:

    private int nextHeadPosition;

    public SSTF(int currentHeadPosition) {

    nextHeadPosition = currentHeadPosition;

    }

    @Override

    public int compare(DiskRequest r1, DiskRequest r2) {

    if (nextHeadPosition - r1.getTrackNumber() < nextHeadPosition - r2.getTrackNumber()) {

    nextHeadPosition = r1.getTrackNumber();

    return -1;

    } else if (nextHeadPosition - r1.getTrackNumber() > nextHeadPosition - r2.getTrackNumber()) {

    nextHeadPosition = r2.getTrackNumber();

    return 1;

    } else {

    return 0;

    }

    }

    with an initial head position of 50 it is producing this order:

    [100, 99, 50, 45, 44, 1]

    The output I am trying to produce:

    [50, 45, 44, 1, 99, 100]

    this might not be posible with comparator

    edit

    SSTF

    for a queue of requests that have track numbers, the first request to be serviced will be the track that is closest to the current position of the head. Each subsequent request will be ordered by least distance from the position of the last request.

    so for a queue with tracks [100, 99, 50, 45, 44, 1] and a current head position of 50, the first request will be 50. The next will be the track closest to 50, which is 45 in this case. lather rinse repeat.

    解决方案

    First, you want to compare the distance between the track and the head position, so you have to use the absolute value in your conditions.

    if (Math.abs(nextHeadPosition - r1.getTrackNumber()) < Math.abs(nextHeadPosition - r2.getTrackNumber()))

    But your compare method modifies the object, which is not a good idea since you don't know how Collections.sort() (I guess that's what you're trying to use) will use it. You have to write your own sorting algorithm I think.

    展开全文
  • 最短寻道时间优先SSTF

    2021-01-12 11:03:16
    /*最短寻道时间优先SSTF(Shortest Seek Time First)算法:选择这样的进程,其要求访 问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短。*/ #include <malloc.h> #include<stdio.h> #...
    /*最短寻道时间优先SSTF(Shortest   Seek  Time   First)算法:选择这样的进程,其要求访 
     问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短。*/
    #include <malloc.h> 
    #include<stdio.h> 
    #include<math.h> 
    typedef struct track{ 
        int column; 
    	struct track *next;
    }node; 
    
    
    int location;        /*当前磁头位置*/ 
    int sum_move;       /*磁头移动总磁道数*/ 
    float ave_move;     /*磁头移动平均磁道数*/ 
    
    node *creat(int num){
        node *head,*p1,*p2 = NULL;
        int i;
        head=NULL;
        for(i=1;i<=num;i++)
        {
            p1=(node *)malloc(sizeof(node));
            scanf("%d",&p1->column);
            if(head==NULL){
                head=p1;
                p2=p1;
            }
            else{
                p2->next=p1;
                p2=p1;
            }
            p2->next=NULL;
            
        }
        return head;
        
    }
    
    int found_SSTF(node *head)    /*找到离当前磁头最近的磁道,并从head 中删除该结点*/ 
    {
    	node *t;
        int temp=1000,a=0,truecol=0;
        t=head;
        while(t)
        {
            
            if(t->column>=location)
            {
                a=t->column-location;
                if(a<temp)
                {
                    truecol=t->column;
                    temp=a;
                }
            }
            else
            {
                a=location-t->column;
                if(a<temp)
                {
                    truecol=t->column;
                    temp=a;
                }
            }
            t=t->next;
        }
        printf("%d   ",truecol);
        sum_move+=temp;
        location=truecol;
        return truecol;
    }
    
    	/*node *p,*r;
    	r=p=head;
    	int a,b;
    	while(p)
    	{
    		a=location-head->column;
    		b=p->next->column-location;
    		if(a<b)
    		{
    			p=p->next;
    			location=head->column;
    		}
    		else
    		{
    			p=p->next;
    			location=p->next->column;
    		}
    	}
    	r=r->next;
    	return head;*/
    
    
    void main() 
    {  
    	int i,num,disk_length; 
    	node *head,*p,*pre,*p1,*p2,*t;
        int xulie;
    	t=(node *)malloc(sizeof(node));
    	printf("输入磁盘柱面总数:\n"); 
    	scanf("%d",&disk_length); 
    	printf("输入磁盘读写请求总数:\n"); 
    	scanf("%d",&num); 
    	printf("输入磁盘读写请求柱面号序列:\n"); 
    	head=creat(num);
    	
    	printf("输入磁盘当前位置为:\n"); 
    	scanf("%d",&location); 
    	
    	printf("\n 依次访问的柱面号为:\n"); 
    	sum_move=0; 
    	for(i=1;i<=num;i++) 
    	{
    		xulie=found_SSTF(head);
            pre=NULL;
            p=head;
            p1=head;
            while(p&&(p->column!=xulie)){
                pre=p;
                p=p->next;
                
            }
            if(p){
                if(!pre) {head=head->next;}
                else pre->next=p->next;
            }
    	} 
    	ave_move=(float)sum_move/num; 
    	
    	printf("\n 总的移动柱面次数为:%d\n ",sum_move); 
    	printf("\n 平均移动次数为:%.2f \n",ave_move); 
    } 
    
    
    展开全文
  • 最短寻道时间优先算法(SSTF)&&扫描算法(SCAN)

    万次阅读 多人点赞 2018-10-19 16:04:52
    最短寻道时间优先算法(SSTF) SSTF问题描述:SSTF算法选择调度处理的磁道是与当前磁头所在磁道距离最近的磁道,以使每次的寻找时间最短。当然,总是选择最小寻找时间并不能保证平均寻找时间最小,但是能提供比FCFS...

    目录

    1,最短寻道时间优先算法(SSTF)

    2,扫描算法(又称电梯算法)


    1,最短寻道时间优先算法(SSTF)

    • SSTF问题描述:SSTF算法选择调度处理的磁道是与当前磁头所在磁道距离最近的磁道,以使每次的寻找时间最短。当然,总是选择最小寻找时间并不能保证平均寻找时间最小,但是能提供比FCFS算法更好的性能。这种算法会产生“饥饿”现象。
    • 1、算法思想:优先选择距当前磁头最近的访问请求进行服务,主要考虑寻道优先。

      2、优点:改善了磁盘平均服务时间。

      3、缺点:造成某些访问请求长期等待得不到服务。

    • 本算法是对输入的磁道首先进行非递减排序,然后判断当前磁头所在的磁道是否在将要寻找的磁道中,分别进行最短寻道时间计算。(如下图示,表示SSTF示意图)

    • 代码实现:
    //最短寻道时间优先SSTF
    #include "pch.h"
    #include <iostream>
    using namespace std;
    //快速排序
    int Partition(int *p, int low, int high)
    {
    	int i = low, j = high, pivot = p[low];
    	while (i < j)
    	{
    		while (i < j&&p[j] >= pivot)
    		{
    			j--;
    		}
    		if (i < j)
    		{
    			p[i] = p[j];
    			i++;
    		}
    		while (i < j&&p[i] <= pivot)
    		{
    			i++;
    		}
    		if (i < j)
    		{
    			p[j] = p[i];
    			j--;
    		}
    	}
    	p[i] = pivot;
    	return i;
    }
    void QuickSort(int *q, int left, int right)
    {
    	if (left < right)
    	{
    		int pivotpos = Partition(q, left, right);
    		QuickSort(q, left, pivotpos - 1);
    		QuickSort(q, pivotpos + 1, right);
    	}
    
    }
    int main()
    {
    	int count = 0;//输入磁盘请求的个数
    	int currentStair;//当前所在的磁道
    	int n;
    	int temp_1, temp_2;
    	int size = 0;//步数计数变量
    	int temp_3, temp_4;
    	cout << "请输入要寻到的数量:" << endl;
    	cin >> count;
    	n = count;
    	int *arr = new int[count];
    	cout << "请输入要寻得磁道:" << endl;
    	for (int i = 0; i < count; i++)
    	{
    		cin >> arr[i];//输入楼梯数
    	}
    	cout << "please input currentstars:" << endl;
    	cin >> currentStair;
    	QuickSort(arr, 0, count - 1);
    	for (int i = 0; i < count; i++)//当前磁道在要寻磁道中
    	{
    		if (currentStair == arr[i]) {
    			currentStair = arr[i];
    			temp_1 = i - 1;
    			temp_2 = temp_1 + 1;
    			while (temp_1 >= 0 && temp_2 < count)
    			{
    				if (abs(currentStair - arr[temp_1]) < abs(arr[temp_2] - currentStair))
    				{
    					size += abs(currentStair - arr[temp_1]);
    					currentStair = arr[temp_1];
    					if (temp_1 > 0)
    						temp_1 -= 1;
    					if (currentStair == arr[temp_1])
    					{
    						while (temp_2 < count)
    						{
    							size += abs(arr[temp_2] - currentStair);
    							currentStair = arr[temp_2];
    							temp_2++;
    						}
    					}
    				}
    				else {
    					size += abs(arr[temp_2] - currentStair);
    					if (temp_2 < count)
    						temp_2 += 1;
    					if (currentStair == arr[temp_2])
    					{
    						while (temp_1 > 0)
    						{
    							size += abs(arr[temp_1] - currentStair);
    							currentStair = arr[temp_1];
    							temp_1--;
    						}
    					}
    
    				}
    			}
    		}
    	}
    	for (int h = 0; h < count; h++)//当前所在的位置不在要寻的磁道中
    	{
    		if (currentStair > arr[h - 1] && currentStair < arr[h])//定位当前的位置
    		{
    			temp_3 = h - 1;
    			temp_4 = h;
    			while (temp_3 >= 0 && temp_4 < count)
    			{
    				if (abs(currentStair - arr[temp_3]) < abs(arr[temp_4] - currentStair))
    				{
    					size += abs(currentStair - arr[temp_3]);
    					currentStair = arr[temp_3];
    					if (temp_3 > 0)
    						temp_3 -= 1;
    					if (currentStair == arr[temp_3])
    					{
    						while (temp_4 < count)
    						{
    							size += arr[temp_4] - currentStair;
    							currentStair = arr[temp_4];
    							temp_4++;
    						}
    					}
    				}
    				else {
    					size += abs(arr[temp_4] - currentStair);
    					currentStair = arr[temp_4];
    					if (temp_4 < count)
    						temp_4 += 1;
    					if (currentStair == arr[temp_4])
    					{
    						while (temp_3 > 0)
    						{
    							size += arr[temp_3] - currentStair;
    							currentStair = arr[temp_3];
    							temp_3--;
    						}
    					}
    
    				}
    			}
    		}
    		else
    			if (currentStair < arr[0])
    			{
    				int i = 0;
    				while (i < count)
    				{
    					size += abs(arr[i] - currentStair);
    					currentStair = arr[i];
    					i++;
    				}
    			}
    			else
    				if (currentStair > arr[count - 1])
    				{
    					int j = count - 1;
    					while (j > 0)
    					{
    						size += abs(arr[j] - currentStair);
    						currentStair = arr[j];
    						j--;
    					}
    				}
    
    	}
    	int average = size / count;
    	cout << "最少寻磁道数是:"<<size<<"平均寻磁道数是:"<<average<< endl;
    }
    	

    2,扫描算法(又称电梯算法)

    • 扫描算法问题描述:SCAN算法在磁头当前移动方向上选择与当前磁头所在磁道距离最近的请求作为下一次服务的对象。由于磁头移动规律与电梯运行相似,故又称为电梯调度算法。SCAN算法对最近扫描过的区域不公平,因此,它在访问局部性方面不如FCFS算法和SSTF算法好。
    • 算法思想:当设备无访问请求时,磁头不动;当有访问请求时,磁头按一个方向移动,在移 [2]  动过程中对遇到的访问  请  求   进行服务,然后判断该方向上是否还有访问请求,如果有则继续扫描;否则改变移动方向,并为经过的访问请求服务,如此反复 。
    • 优点:克服了最短寻道优先的缺点,既考虑了距离,同时又考虑了方向。(如下图表示SCAN图示)

    • 代码实现:
    import java.util.Scanner;
    public class Test_louti {
    //本算法我假设楼梯最大到200层,
    		public static void main(String[] args) {
    			System.out.println("please input your scan from 1 to 200:");
    			Scanner input =new Scanner(System.in);
    			int []arr=new int[200];//200楼电梯
    			System.out.println("请输入你要输入的楼层数:");
    			int number=input.nextInt();//number记录当前所在楼梯
    			int b=0;
    			System.out.println("请输入楼梯:");
    			for(int i=0;i<=200;i++)
    			{
    				if(b<number){
    				int num=input.nextInt();
    				arr[num]=num;//记住楼梯,从小到大
    				b++;
    				i++;
    				}
    				if(b==number)
    					break;
    			}
    			System.out.println("请输入当前楼梯号码:");
    			int currentScan=input.nextInt();//当前楼梯
    			int i=currentScan,team=0,j=0,a=currentScan;
    			arr[currentScan]=currentScan;
    			while(i<200)//i记住当前判断的楼梯号码
    			{
    				if(arr[i]!=0)
    				{
    					team+=(arr[i]-arr[currentScan]);
    					currentScan=i;
    					j=i;//记住最后的楼梯号码
    				}
    				i+=1;
    			}
    			//下半层
    			while(a>0)
    			{
    				if(arr[a]!=0)
    				{
    					team+=Math.abs((arr[a]-arr[j]));
    					j=a;	
    				}
    				a-=1;
    			}
    			System.out.println("总的移动量是:"+team);
    		}
    		}
    

     

    展开全文
  • 操作系统实验-磁盘调度:先来先服务、最短寻道时间算法
  • 最短寻道时间优先(SSTF,Shortest Seek Time First) 该算法选择这样的过程,其要求访问的的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短。但这种算法不能保证平均寻道时间最短。下图示出了按SSTF算法...

    最短寻道时间优先(SSTF,Shortest Seek Time First)

    该算法选择这样的过程,其要求访问的的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短。但这种算法不能保证平均寻道时间最短。下图示出了按SSTF算法进行调度时,各种进程被调度的次序、每次磁头移动的距离,以及9次调度磁头平均移动的距离。
    在这里插入图片描述

    展开全文
  • FCFS SSTF SCAN 算法 先来先服务 最短寻道时间优先 扫描
  • 自己写的磁盘调度算法,通俗易懂,其中有先来先服务调度算法,最短寻道时间调度算法、电梯调度算法
  • 先来先服务(FCFS)、最短寻道时间优先(SSTf)、扫描算法(SCAN)、循环扫描算法(CSCAN)最后有运行截图。#include#include#include#includeint a; //当前磁道号int b; //磁头运动方向int c[10]; //要访问的柱面号int num;...
  • 用c++语言来实现对于磁盘移臂调度的模拟,模拟的算法有先来先服务法和最短寻道时间优先法
  • 最近在腾讯的笔试题中看到最短寻道时间的题目,然后就去看了下相关资料,了解了下SSTF算法的实现(原理就是优先访问离当前读写头最近的位置) 例如:磁盘访问序列为:35,12,73,230,80,20,310,120 读写头...
  • 最短寻道时间优先(SSTF)和扫描(SCAN)算法。理解各调度算法的工作原理 对给出的任意的磁盘请求序列、计算平均寻道长度;要求可定制磁盘请求序列长度、磁头起始位置、磁头移动方向。 测试:假设磁盘访问序列:98,...
  • 磁盘移臂调度过程模拟设计--电梯算法、最短寻道时间优先算法
  • 磁盘调度-最短寻道时间优先(SSTF)

    千次阅读 2018-09-30 19:19:57
    最短寻道时间优先:其要求访问的磁道与当前磁头所在的距离最近。 算法思想:首先排序,找出当前第一个大于等于当前磁头所在位置,设置两个指针,分别代表左右两个磁道号,比较两个磁道号大小即可得到离起始磁道最近...
  • 磁盘调度算法(先来先服务。最短寻道时间算法) 操作系统课程设计
  • 磁盘移臂调度过程模拟设计--先来先服务法、最短寻道时间优先算法
  • 操作系统实验之磁盘调度算法模拟(最短寻道时间优先SSTF 和 扫描算法SCAN) 最短寻道时间优先SSTF 要求每次访问的磁道与当前磁头所在的磁道距离最近、 也就是每次访问距离磁头最近的磁道 扫描算法SCAN 由里向外地...
  • 模拟实现磁盘调度算法:最短寻道时间优先(SSTF)和扫描(SCAN)算法。 实验步骤: 理解各调度算法的工作原理 对给出的任意的磁盘请求序列、计算平均寻道长度;要求可定制磁盘请求序列长度、磁头起始位置、磁头...
  • 先简单介绍一下这几种算法: 1、先来先服务:最早提交最早访问。 例如:磁盘访问序列:98...2、最短寻道时间优先:离读写头最近的最早访问。 例如:磁盘访问序列:98,183,37,122,14,124,65,67。 读写头起...
  • 实现磁盘调度的一些功能,如:先来先服务算法(FCFS),最短寻道时间优先算法(SSTF),扫描算法(SCAN),循环扫描算法(CSCAN),N步扫描算法(NStepScan)
  • 模拟最短寻道时间优先SSTF算法

    千次阅读 2017-09-17 09:39:25
    选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短#include <malloc.h> #include<stdio.h> #include<math.h> #include <limits.h> typedef struct track{ int column; ...
  • (1)设计并实现了一个函数,完成先来先服务的磁盘调度功能 (2)设计并实现了一个函数完成最短寻道时间优先的磁盘调度功能。 (3)设计并实现了一个函数完成电梯算法的磁盘调度功能。
  • 最短寻道时间优先算法-C++

    千次阅读 2020-06-06 03:00:43
    最短寻找时间优先调度算法总是从等待访问者中挑选寻找时间最短的那个请求先执行的,而不管访问者到来的先后次序。比如现有需要读取的数据的柱面次序为:35 12 73 230 80 20 310 120,初始柱面为65号,当65操作结束后...
  • 最短寻道时间优先算法(SSTF)

    千次阅读 2020-10-22 16:55:59
    SSTF算法选择调度处理的磁道是与当前磁头所在磁道距离最近的磁道,以使每次的寻找时间最短。当然,总是选择最小寻找时间并不能保证平均寻找时间最小,但是能提供比FCFS算法更好的性能。这种算法会产生“饥饿”现象。...
  • 模拟实现磁盘调度算法:最短寻道时间优先(SSTF)和扫描(SCAN)算法。实验步骤:理解各调度算法的工作原理对给出的任意的磁盘请求序列、计算平均寻道长度;要求可定制磁盘请求序列长度、磁头起始位置、磁头移动方向...
  • 可以对给出的任意的磁盘请求序列、计算平均寻道长度; 要求可定制磁盘请求序列长度、磁头起始位置、磁头移动方向。 测试:假设磁盘访问序列:98,183,37,122,14,124,65,67;读写头起始位置:53,方向:磁道...
  • 该算法要求访问的磁道与当前磁头所在的距离你最近,使寻道时间最短 例如给数据90,58,55,39,38,18,150,160,184 平均寻道长度为27.5 原理见汤子瀛的《操作系统》第四版 p233页 首要的是分析如何才能找到第一个最接近...
  •  掌握磁盘调度算法,如先来先服务(firstcome first served,FCFS)调度算法、最短寻道时间优先(shortest seek timefirst,SSTF)调度算法、扫描(SCAN)调度算法、循环扫描(C-SCAN)调度算法。二、 实验内容设计...
  • 含本人实验报告,有具体流程图,实验课上写的,有更好的想法可以提出,大家一起学习,赚点积分不容易 C语言编写,调试过可运行,含实验...实验7,磁盘调度算法(一)——先来先服务(FCFS)和最短寻道时间优先(SSTF)

空空如也

空空如也

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

最短寻道时间