硬算法实现

Question

I couldn't implement SJF(Shortest Job First) Algorithm.

SJF work like this

If process arrived 0 time it'll work till the next process arrival the algorithm have to check if the arrival (process/processes) which arrived in 1 are shorter than the current remaining time
Example: P0 executed 1 and still 2 to finish, now we have P0,P1,P2,P3,P4 in 1 algorithm will execute the shortest one P3, and after it P0 then P4 then P1 and so on. The problem is I have to save to all processes their start and end time execution, and the waiting time.

This is my latest algorithm. (Some wrong cases occurs)

input data:

Process Arrival Burest 
P0      0       3
P1      0       4
P2      0       5
P3      1       1
p4      1       3

for (i = 0; i < proc.Count; i++)
{
    minProcIndex = i;
    for (x = i; x < proc.Count; x++)
    {
        for (int y = 0 ; y < proc.Count; y++)
        {
            if (y == minProcIndex)
                continue;

            if (tempBrust[minProcIndex] - tempArrival[y] > tempBrust[y] 
                && tempBrust[y] != 0)
            {
                tempBrust[minProcIndex] -= tempArrival[y];
               // tempArrival[minProcIndex] += tempArrival[y];
                clock += tempArrival[y];
                //proc[y].start = clock;
                minProcIndex = y;
            }
            else if (y != proc.Count -1)
                continue;
            else
            {
                if (y == 0)
                {
                    proc[minProcIndex].start = 0;
                }
                else if (proc[y].start > 0)
                {
                    proc[y].start = clock;
                }
                else
                proc[minProcIndex].start = clock;

                proc[minProcIndex].end = proc[minProcIndex].brust + clock;
                tempBrust[minProcIndex] = 0;
                clock += proc[minProcIndex].brust;
                if (minProcIndex == proc.Count - 1)
                    minProcIndex = 0;
                else
                minProcIndex++;
                for (int c = 0; c < proc.Count; c++)
                {
                    if (tempArrival[c] < clock)
                        tempArrival[c] = clock - 1;
                }
            }
        }
    }
}

Answer 1

I think this is easier if you create a class to hold the process information

public class ProcessInformation
{
    public string Name { get; private set; }
    public int Duration { get; private set; }
    public int ArrivalTime { get; private set; }

    public int TimeLeft { get; set; }
    public int? StartTime { get; set; }
    public int? EndTime { get; set; }
    public List<int> InterruptTimes { get; private set; }

    public ProcessInformation(string name, int arrivalTime, int duration)
    {
        Name = name;
        ArrivalTime = arrivalTime;
        Duration = duration;
        TimeLeft = duration;
        InterruptTimes = new List<int>();
    }
}

Then you can just run the following code

var processes = new List<ProcessInformation>
                {
                    new ProcessInformation("P0", 0, 3),
                    new ProcessInformation("P1", 0, 4),
                    new ProcessInformation("P2", 0, 5),
                    new ProcessInformation("P3", 1, 1),
                    new ProcessInformation("P4", 1, 3)
                };

int currentTime = 0;
ProcessInformation currentProcess = null;
while (processes.Any(p => p.TimeLeft > 0))
{
    var shortest =
        processes.Where(p => p.ArrivalTime <= currentTime && p.TimeLeft > 0)
            .OrderBy(p => p.TimeLeft)
            .FirstOrDefault();

    if (currentProcess != null && currentProcess.TimeLeft > 0 && shortest != currentProcess)
    {
        currentProcess.InterruptTimes.Add(currentTime);
    }

    if (shortest != null)
    {
        if (shortest.StartTime == null) shortest.StartTime = currentTime;
        shortest.TimeLeft--;
        if (shortest.TimeLeft == 0) shortest.EndTime = currentTime + 1;
    }

    currentProcess = shortest;
    currentTime++;
}

foreach (var p in processes)
{
    Console.WriteLine(
        "Process {0} arrived {1} started {2} ended {3} duration {4} wait {5} interrupt times {6}", 
        p.Name, 
        p.ArrivalTime, 
        p.StartTime, 
        p.EndTime, 
        p.Duration, 
        p.EndTime - p.ArrivalTime - p.Duration,
        p.InteruptTimes.Any() ? string.Join(", ", p.InteruptTimes) : "None");
}

which outputs the following

Process P0 arrived 0 started 0 ended 4 duration 3 wait 1 interrupt times 1

Process P1 arrived 0 started 7 ended 11 duration 4 wait 7 interrupt times None

Process P2 arrived 0 started 11 ended 16 duration 5 wait 11 interrupt times None

Process P3 arrived 1 started 1 ended 2 duration 1 wait 0 interrupt times None

Process P4 arrived 1 started 4 ended 7 duration 3 wait 3 interupt times None