Average waiting time of SJF and Round Robin scheduling

求non-preemptive Shortest Job First与Round Robin的平均等待时间。

输入为两个array，一个为到达时间，一个为执行时间。对于Round Robin还另外有time slice.

直接看代码吧。思路挺直接的，就想象自己就是处理器，有一个CPU时间一直在走，到点该做什么做什么。不过得注意细节。

还有想清楚waiting time是怎么得到的，比如对于RR，等待时间 = 结束时间 - 到达时间 - 执行时间。

SJF：

public class ShortestJobFirst {
    class Node {
        int startTime;
        int burstTime;
        Node(int s, int b) {
            startTime = s;
            burstTime = b;
        }
    }

    public int average(int[] arr, int[] bur) {
        if (arr == null || bur == null || arr.length == 0 || bur.length == 0) {
            return 0;
        }
        //use PriorityQueue to get shortest job
        PriorityQueue<Node> queue = new PriorityQueue<Node>(arr.length, new Comparator<Node>(){
            @Override
            public int compare(Node n1, Node n2) {
                return n1.burstTime - n2.burstTime;
            }
        });
        
        int timeStep = 0;
        int index = 0;
        int excTime = 0;
        int waitTime = 0;


        while(true) {
            while(index < arr.length && arr[index] <= timeStep) {
                queue.add(new Node(arr[index], bur[index]));
                index++;
            }
            
            Node cur = queue.poll();
            if (cur != null) {
                waitTime += timeStep - cur.startTime;
                excTime = cur.burstTime;
                timeStep += excTime;
            }else{
                timeStep++;
            }
            
            if (index >= arr.length && queue.isEmpty()) {
                break;
            }
        }
        return waitTime / arr.length;

    }
    
    public static void main(String[] args) {
        int[] arrival = {0, 2, 4, 5};
        int[] burst = {7, 4, 1, 4};
        ShortestJobFirst test = new ShortestJobFirst();
        int res = test.average(arrival, burst);
        System.out.println(res);
    }
}

Round Robin：

public class RoundRobin {
    class Node {
        int startTime;
        int burstTime;
        int leftExcTime = 0;
        Node(int s, int b) {
            startTime = s;
            burstTime = b;
            leftExcTime = b;
        }
        Node(int s, int b, int l) {
            startTime = s;
            burstTime = b;
            leftExcTime = l;
        }
    }
    public int average (int[] arr, int[] bur, int unit) {
        if (arr == null || bur == null || arr.length == 0 || bur.length == 0) {
            return 0;
        }
        Queue<Node> queue = new LinkedList<Node>();

        int timeStep = 0;
        int index = 0;
        int waitTime = 0;
        while (true) {
            //add node to waiting queue
            while (index < arr.length && arr[index] <= timeStep) {
                queue.add(new Node(arr[index], bur[index]));
                index++;
            }
            Node cur = queue.poll();
            if (cur != null) {
                if (cur.leftExcTime > unit) {
                    timeStep += unit;
                    //add new arrival into waiting queue first,
                    while (index < arr.length && arr[index] <= timeStep) {
                        queue.add(new Node(arr[index], bur[index]));
                        index++;
                    }
                    //then add "current" task back
                    queue.add(new Node(cur.startTime, cur.burstTime, cur.leftExcTime - unit));
                } else{
                    timeStep += cur.leftExcTime;
                    waitTime += timeStep - cur.startTime - cur.burstTime;
                }
            }else{
                timeStep++;
            }
            
            if (index >= arr.length && queue.isEmpty()) {
                break;
            }
        }
        return waitTime / arr.length;
    }
    public static void main(String[] args) {
        int[] arr = {0,2,4,5};
        int[] bur = {7,4,1,4};
        RoundRobin test = new RoundRobin();
        System.out.println(test.average(arr, bur, 3));
        
    }
}

 应该还有不使用额外空间的办法吧。如果有更好解法的欢迎指教哈。