最短任务调度算法

package com.mmall.common.program;

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

/**
 * Created by Workstation on 2017/8/23.
 * 实现最短任务调度算法，求其中平均等待时间
 */
public class SJB {

    public static void main (String[] args) {
      /*  Scanner sc=new Scanner (System.in);

        int N=sc.nextInt ();

        int Commitmatrix[]=new int[N];// 提交时间 从0开始进行排序
        int Service[]=new int[N];// 任务的服务时间

        for(int i=0;i<N;i++)
        {
            Commitmatrix[i]=sc.nextInt ();
        }

        for(int i=0;i<N;i++)
        {
            Service[i]=sc.nextInt ();
        }
    */
      int[] Commitmatrix={0,1,2,3,4};
      int N=5;
      int Service[]={4,3,5,2,4};
        Shorttask(Commitmatrix,Service,N);
    }

    private static void Shorttask (int[] Com, int[] Ser, int n) {
        int [] visited=new int[n];// 标记作业是否已经被调度过 ，从0-Com 时间中挑选最短任务
        double wait_time=0.0;
        int start_time=0;// 当前任务运行开始时间
        int cur=0;// 调度任务的下标

        Map<Integer,Integer> map=new TreeMap<> ();//

        int[] waitwork=new int[n]; int next=0;
        for(int i=0;i<n;i++)
        {
            wait_time+=Math.abs(start_time-Com[cur]); // 出现 Com>start_time
            start_time+=Ser[cur];//记录下一次调度开始时间

            visited[cur]=1;

            // 在 服务时间中挑选最短任务时间 j表示任务索引
            int num=0;
            for(int j=1;j<n;j++)
            {
                if(visited[j]==0 && Com[j]<=start_time) // 将0-start_time 提交的任务记录下来
                {
                    //map.put(Ser[j],j);
                    waitwork[num++]=j;
                }
            }

            // 寻找最短的作业，注意map为空，提交时间> 服务时间，只能够
            if(num>0)
            {
                next=getMintask(waitwork,num,Ser);
            }else // 就绪队列中没有任务，只能从挑选出下一个任务,相当于重新开始一样
            {
                if(i+1<n)
                {
                    next=i+1;
                    wait_time+=Math.abs(start_time-Com[next]);// 就绪队列NULL，向下添加新的任务，整个任务分隔成两个单独任务
                    start_time=Com[next];
                }


            }
            cur=next;
        }
        System.out.println(wait_time/n);
    }

    private static int getMintask (int[] waitwork, int num,int[] Ser) {
        int min=Integer.MAX_VALUE;
        int next=0;
        if(num>0) // 队列中用于准备就绪任务，从其中挑选出最短任务时间
        {
            for(int k=0;k<num;k++)
            {
                if(Ser[waitwork[k]]<min)
                {
                    min=Ser[waitwork[k]];
                    next=waitwork[k];
                }
            }
        }
        return next;
    }
}

/***
 *  ABCDEFG:0,1,2,3,4,15,16
 *  A-D-B-C-E-F-G: 
 *  4-2-3-5-15-16-17
 *  平均时间 0+4-3+6-1+9-2=13 等待时间
 *  开始时间执行到C之后没有就绪队列 4+2+3+5=14 下一个任务开始时间 15 中间等待时间13+1=14 ---之后相当于重新开始另外一个任务
 *  14+0+4-1+12-2=27 总的等待时间 27/7=3.85
 * */