【问题标题】:SJF Algorithm Sorting C#SJF 算法排序 C#
【发布时间】:2012-12-08 00:42:41
【问题描述】:

这是我的代码。我想使用更快的排序算法,可能是快速排序或梳状排序。
我首先根据到达时间对列表进行了两次排序,然后是时间。
我需要帮助实现更快的排序算法
我的主要 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();
        }


上课流程

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;
    }

【问题讨论】:

  • 您的问题是什么?
  • 你是在吹牛还是你的代码有问题???还是很简单:我想使用快速排序?
  • List.Sort 使用快速排序进行 O(n log n) 比较
  • list.sort 在这里效率不高,因为我需要先对到达进行两次排序,然后对粗暴进行排序。
  • 作为参考,这个问题似乎是为了回应我在 CodeReview.SE 上对 Ayman 上一个问题的回答:codereview.stackexchange.com/a/19788/8243

标签: c#


【解决方案1】:

我建议您查看Parallel Sort Algorithm 以获得灵感。

我还假设您需要某种帮助来实现它,对于上述解决方案,这将类似于

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

但是请尝试提出一个明确的问题:)

将 IComparable 接口的定义添加到您的流程类中;

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);
  }
}

到目前为止,按照我所说的进行,您将得到一轮排序,并且还会使您的代码更具可读性:)

如果你有任何问题,尽管问:)

【讨论】:

    猜你喜欢
    • 2013-01-12
    • 1970-01-01
    • 1970-01-01
    • 2018-05-17
    • 2019-04-03
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多