Java中的扫描算法

所以我在用Java做扫描算法（操作系统）时遇到了一些问题。我已经使用最短寻道时间优先算法来计算磁盘优化：

private int[] arrangeBySSTF(int current, int sequence[])
{
    int n = sequence.length;
    int sstf[] = new int[n];
    for(int i =0; i < n; i++){
        sstf[i] = sequence[i];
    }

    int ii = -1;
    for(int i =0; i<n; i++)
    {
        int minimum = Integer.MAX_VALUE;
        ii = i;
        for(int j = i; j < n; j++)
        {
            int distance = Math.abs(current - sstf[j]);
            if(distance < minimum)
            {
                ii = j;
                minimum = distance;
            }
        }
        int tmp = sstf[i];
        sstf[i] = sstf[ii];
        sstf[ii] = tmp;
        current = sstf[i];
    }
    return sstf;
}

private int[]arrangeBySTF（int-current，int-sequence[]）
{
int n=序列长度；
int-sstf[]=新的int[n]；
对于（int i=0；ifor（inti=0；i扫描算法通过向一个方向提供请求来工作

import java.util.Arrays;
private int[] arrangeBySCAN(int current, int sequence[]) {
    // Assuming inward movement i.e going toward zero
    int n = sequence.length;
    int scan[] = new int[n + 1];
    int temp[] = new int[n + 1];
    for (int i = 0; i < n; i++) {
        temp[i] = sequence[i];
    }
    temp[n] = 0;
    Arrays.sort(temp);
    // find first element in array temp which is less than current
    int index = 0;
    for (int i = 1; i < temp.length; i++) {
        if (temp[i] > current) {
            index = i - 1;
            break;
        }
    }
    int k = 0;
    // Server all request upto zero move backward
    for (int i = index; i >= 0; --i, ++k) {
        scan[k] = temp[i];
    }
    // move forward from zero
    for (int i = index + 1; i < temp.length; i++, ++k) {
        scan[k] = temp[i];
    }
    return scan;
}

导入java.util.array；
专用int[]arrangeBySCAN（int当前，int序列[]）{
//假设向内移动，即向零移动
int n=序列长度；
整数扫描[]=新整数[n+1]；
int temp[]=新的int[n+1]；
对于（int i=0；i电流）{
指数=i-1；
打破
}
}
int k=0；
//服务器所有请求最多为零向后移动
对于（int i=索引；i>=0；--i，++k）{
扫描[k]=温度[i]；
}
//从零向前移动
对于（int i=索引+1；i

该算法的工作原理是首先对序列进行排序，然后找到一个小于当前值的请求，并为所有请求提供服务，直到零。在此服务器之后，通过从零向前移动来处理剩余的请求

在上述代码中，只需使用一个数组而不是2个数组，并使用二进制搜索来查找小于当前值的第一个元素，就可以进行多次优化。我希望您可以自己进行优化。
希望这篇文章有适当的文档记录，以便您理解：

package diskScheduling;
import java.util.*;
public class SCAN {

    public static int  callSCAN(int arr[],int init,int maxreq){
        /* In this algorithm head moves only in one direction and
         *  on reaching the boundary its reverses its direction 
         *  Here in this algorithm , we implement it move in forward direction first
         *  ,i.e towards higher track requests,then towards lower track request*/

        int sum=0,len=arr.length;

        //sorting the requests
        Arrays.sort(arr);

        //finding virtual location of init in the request array
        //binary search returns the index of search element if found 
        //else it returns -(insertion point) -1
        int pos=    Arrays.binarySearch(arr, init);

        pos=-pos-1;
//      System.out.println(pos);
        int left=pos-1,right=pos;

        //moving towards right side first in the array
        sum+=Math.abs(init-arr[right]);
        System.out.println(arr[right]);
        while(right<len-1){
            sum+=Math.abs(arr[right]-arr[right+1]);
            System.out.println(arr[right+1]);
            right++;
        }
        /* moving to maximum possible track request from
         *  where head will reverse its direction  */
        sum+=Math.abs(arr[len-1]-maxreq);
        System.out.println(maxreq);


        //now moving towards left direction .
        sum+=Math.abs(maxreq-arr[left]);
        System.out.println(arr[left]);

        while(left!=0){
            sum+=Math.abs(arr[left]-arr[left-1]);
            System.out.println( arr[left-1]);
            left--;
        }
        return sum;
    }
    public static void main(String[] args) {
        //maxreq maximum possible disk request
        int maxreq = 200;
        //request array
        int arr[]={98,183,37,122,14,124,65,67};
        // disk head starts at init
        int init=53;
        int res=callSCAN(arr,init,maxreq);
        System.out.println("Total Head Movement= "+res);
    }

}

包磁盘调度；
导入java.util.*；
公共类扫描{
公共静态int-callSCAN（int-arr[]，int-init，int-maxreq）{
/*在该算法中，头部仅向一个方向移动，并且
*到达边界时，它会反转方向
*在这个算法中，我们首先实现向前移动
*，即向更高的跟踪请求，然后向更低的跟踪请求*/
int sum=0，len=arr.length；
//对请求进行排序
数组。排序（arr）；
//在请求数组中查找init的虚拟位置
//二进制搜索返回搜索元素的索引（如果找到）
//否则返回-（插入点）-1
int pos=Arrays.binarySearch（arr，init）；
pos=-pos-1；
//系统输出打印项次（pos）；
int左=位置1，右=位置；
//在数组中首先向右侧移动
sum+=Math.abs（init arr[right]）；
System.out.println（arr[右]）；
虽然（对）不太清楚。请给我们看一下输入、输出和您想要的输出示例。这是关于操作系统中磁盘优化的算法计算