用c#实现rr算法，要求1）输入时间片和各进程运行时间（以空格间隔），手动输入。 2）结果输出各进程的开始时间和结束时间、进程的平均等待时间，和具体的甘特图。

好的，下面是使用 C# 实现 RR（Round Robin）算法的示例代码，希望对你有所帮助。

using System;
using System.Collections.Generic;

namespace RoundRobin
{
    class Process
    {
        public int pid; // 进程号
        public int exeTime; // 执行时间
        public int waitTime; // 等待时间
        public int startTime; // 开始时间
        public int finishTime; // 完成时间
        public int remainTime; // 剩余时间
    }

    class Program
    {
        static void Main(string[] args)
        {
            int n; // 进程个数
            int timeSlice; // 时间片
            Console.Write("请输入时间片：");
            timeSlice = int.Parse(Console.ReadLine());
            Console.Write("请输入进程个数：");
            n = int.Parse(Console.ReadLine());

            List<Process> p = new List<Process>(n); // 进程数组

            // 输入各进程信息
            for (int i = 0; i < n; i++)
            {
                Process process = new Process();
                Console.Write("请输入进程" + (i + 1) + "的执行时间：");
                process.exeTime = int.Parse(Console.ReadLine());
                process.pid = i + 1;
                process.remainTime = process.exeTime;
                p.Add(process);
            }

            int curTime = 0; // 当前时间
            int i = 0; // 当前进程下标
            int count = n; // 进程剩余个数
            Queue<Process> readyQ = new Queue<Process>(); // 就绪队列

            while (count > 0)
            {
                // 将到达时间小于等于当前时间的进程加入就绪队列
                while (i < n && p[i].exeTime <= curTime)
                {
                    readyQ.Enqueue(p[i]);
                    i++;
                }

                if (readyQ.Count == 0)
                {
                    curTime += timeSlice;
                    continue;
                }

                // 执行时间片
                Process curProcess = readyQ.Dequeue();
                curProcess.remainTime -= timeSlice;
                curTime += timeSlice;

                // 更新等待时间、开始时间、完成时间
                for (int j = 0; j < n; j++)
                {
                    if (p[j].pid != curProcess.pid && p[j].remainTime > 0)
                    {
                        p[j].waitTime += timeSlice;
                    }
                }

                if (curProcess.remainTime <= 0)
                {
                    curProcess.finishTime = curTime;
                    curProcess.remainTime = 0;
                    count--;
                }
                else
                {
                    readyQ.Enqueue(curProcess);
                }
            }

            // 输出结果
            Console.WriteLine();
            Console.WriteLine("进程\t开始时间\t完成时间\t等待时间");
            double sumWaitTime = 0.0;
            for (int k = 0; k < n; k++)
            {
                p[k].startTime = p[k].finishTime - p[k].exeTime;
                Console.WriteLine(p[k].pid + "\t" + p[k].startTime + "\t\t" + p[k].finishTime + "\t\t" + p[k].waitTime);
                sumWaitTime += p[k].waitTime;
            }
            Console.WriteLine("平均等待时间：" + sumWaitTime / n);

            // 输出甘特图
            Console.WriteLine();
            Console.WriteLine("甘特图：");
            for (int k = 0; k < n; k++)
            {
                Console.Write("进程" + p[k].pid + "：");
                for (int j = 0; j < p[k].exeTime; j++)
                {
                    Console.Write("*");
                }
                Console.WriteLine();
            }
        }
    }
}

该程序实现了 RR（Round Robin）算法，可以手动输入时间片和各进程的执行时间。程序输出了各进程的开始时间、完成时间、等待时间和平均等待时间，以及甘特图。希望能够对你有所帮助！