SJF Algorithm Sorting C#

Question

Cest mon code. Je veux utiliser un algorithme de tri plus rapide, peut-être un tri rapide ou un tri en peigne.
J'ai trié la liste deux fois d'abord en fonction de l'arrivée, puis à l'heure de la fièvre.
i besoin d'aide pour mettre en œuvre un algorithme plus rapide tri
Mon principal mwthod

static void Main(string[] args) 
     { 
      //----------------------------------------Reading I/O File-------------------------------------- 
      string s = Environment.CurrentDirectory.ToString(); // returns the directory of the exe file 
      if (File.Exists(s + @"\input.txt")) //checking if the input files exists 
       Console.WriteLine("File Exists"); 
      else 
      { 
       Console.WriteLine("File Not Found"); 
       Console.WriteLine("-----------------------------------------------------"); 
       return; 
      } 
      Console.WriteLine("-----------------------------------------------------"); 
      //----------------------------------------Data Into List-------------------------------------- 
      string FileText = File.ReadAllText(s + @"\input.txt"); //reading all the text in the input file 
      string[] lines = FileText.Split('\n'); //splitting the lines 
      List<Process> processes = new List<Process>(); 
      for (int i = 1; i < lines.Length; i++) 
      { 
       string[] tabs = lines[i].Split('\t');//splitting the tabs to get objects' variables 
       Process x = new Process(tabs[0], int.Parse(tabs[1]), int.Parse(tabs[2]), int.Parse(tabs[3]));//creating object 
       processes.Add(x);//adding object to the list 
      } 
      // ----------------------------------------Sorting The List-------------------------------------- 
      Process temp; 
      for (int k = 0; k < processes.Count; k++) 
      { 
       for (int i = k + 1; i < processes.Count; i++) 
       { 
        if (processes[k].arrivalTime > processes[i].arrivalTime) 
        { 
         temp = processes[i]; 
         processes[i] = processes[k]; 
         processes[k] = temp; 
        } 
       } 
      } 
      int tempClock = 0; 
      for (int i = 0; i < processes.Count; i++) 
      { 
       if (processes[i].arrivalTime > tempClock) 
        tempClock = processes[i].arrivalTime; 
       for (int k = i + 1; k < processes.Count; k++) 
       { 
        if (processes[k].arrivalTime <= tempClock && processes[k].brust < processes[i].brust) 
        { 
         temp = processes[i]; 
         processes[i] = processes[k]; 
         processes[k] = temp; 
        } 
       } 
       tempClock += processes[i].brust; 
      } 
      Console.WriteLine("Processes After Sorting"); 
      Console.WriteLine("-----------------------------------------------------"); 
      Console.WriteLine("Name\tArrival\tBrust\tPriority"); 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t" + processes[i].arrivalTime + "\t" + processes[i].brust + "\t" + processes[i].priority); 
       Console.WriteLine(); 
      } 
      Console.WriteLine("-----------------------------------------------------"); 
      //----------------------------------------Gantt Chart-------------------------------------- 
      Console.WriteLine("Gantt Chart"); 
      Console.WriteLine("-----------------------------------------------------"); 
      int counter = 0; 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t"); 
       if (processes[i].arrivalTime < counter) 
        printSpaces(counter); 
       else 
       { 
        printSpaces(processes[i].arrivalTime); 
        counter = processes[i].arrivalTime; 
       } 
       printHashes(processes[i].brust); 
       counter += processes[i].brust; 
       Console.WriteLine(); 
      } 
      Console.WriteLine("-----------------------------------------------------"); 
      //-----------------------------------Completing Data And final Table------------------------- 
      int clock = 0, totalwait = 0, totalturnAround = 0; 
      for (int i = 0; i < processes.Count; i++) 
      { 
       if (processes[i].arrivalTime > clock) 
       { 
        processes[i].start = processes[i].arrivalTime; 
        clock += processes[i].start - processes[i].arrivalTime; 
        clock += processes[i].brust; 

       } 
       else 
       { 
        if (i > 0) 
         processes[i].start = processes[i - 1].end; 
        clock += processes[i].brust; 
       } 
       if (processes[i].start > processes[i].arrivalTime) 
        processes[i].wait = processes[i].start - processes[i].arrivalTime; 
       else processes[i].wait = 0; 
       processes[i].end = processes[i].start + processes[i].brust; 
       processes[i].turnAround = processes[i].wait + processes[i].brust; 
       totalwait += processes[i].wait; 
       totalturnAround += processes[i].turnAround; 
      } 
      Console.WriteLine("Name\tArrival\tBrust\tStart\tEnd\tWait\tturnaround"); 
      for (int i = 0; i < processes.Count; i++) 
      { 
       Console.Write(processes[i].name + "\t" + processes[i].arrivalTime + "\t" + processes[i].brust + "\t" + processes[i].start + "\t" + processes[i].end + "\t" + processes[i].wait + "\t" + processes[i].turnAround); 
       Console.WriteLine(); 
      } 
      double att = 0, awt = 0; 
      awt = (double)totalwait/(double)processes.Count; 
      att = (double)totalturnAround/(double)processes.Count; 
      Console.WriteLine("A.W.T= {0}", awt + "\t A.T.T= " + att); 
      Console.ReadKey(); 
     } 

classe Process

class Process 
    { 
     public Process(string name, int arrivalTime, int brust, int priority) 
     { 
      this.name = name; 
      this.arrivalTime = arrivalTime; 
      this.brust = brust; 
      this.priority = priority; 
     } 
     public Process() 
     { 

     } 
     public string name; 
     public int arrivalTime; 
     public int brust; 
     public int priority; 
     public int wait; 
     public int end; 
     public int start; 
     public int turnAround; 
    } 

Answer 1

Je vous recommande d'avoir à regarder Parallel Sort Algorithm pour l'inspiration.

Je suppose que vous voulez une sorte d'aide mise en œuvre, qui, avec la solution ci-dessus serait quelque chose comme

// The contents of processes must implement IComparable<T> 
QuicksortParallelOptimised(processes, 0, processes.Count); 

Mais ne s'il vous plaît essayer de formuler une question claire :)

Ajout la définition de l'interface IComparable à votre classe de processus;

partial class Process : IComparable<Process> 
{ 
    public override int CompareTo(Process otherProcess) 
    { 
    if (this.arrivalTime == otherProcess.arrivalTime) 
     return this.brust.CompareTo(otherProcess.brust); 
    return this.arrivalTime.CompareTo(otherProcess.brust); 
    } 
} 

Faire ce que je l'ai dit si bien ne vous laisser avec un tour de tri, et il serait également rendre votre code un enfer de beaucoup plus facile à lire :)

Si vous avez des questions seulement ask :)