在一单道批处理系统中，一组作业的提交时间和运行时间如下表所示。试计算以下三种作业调度算法的平均周转时间T和平均带权周转时间W。

（1）先来先服务调度算法。
（2）短作业优先调度算法。
（3）高响应比优先调度算法。

解：①先来先服务算法

T=1/4(1.5+1.5+1.5+1.5)=1.5

W=1/4(1+1.5+3+15)=5.125

解析：先来先服务就是根据作业顺序进行计算就可以了。这里的周转时间=结束时间-提交时间

                                                                                              带权周转时间=周转时间/运行时间

②短作业优先调度算法

T=1/4(1.5+2.1+0.5+0.5)=1.15

W=1/4(1+2.1+1+5)=（9.1）/4

解析：短作业优先调度算法根据第一个运行时间然后进行第二个运行时间判断，第一个作业的结束时间为7.5.那么就有作业2和作业3可以运行，根据作业运行时间进行判断，时间短的首先运行，这里作业3的运行时间短，所以先运行作业3.

然后继续进行判断，当前的时间已经到了8.0，作业2和作业4进行判断，选择作业4，剩下的再运行作业2.

周转时间和带权周转时间根据上面的公式进行计算即可。

③高响应比优先调度算法

T=1/4(1.5+1.5+1.6+1)=1.4

W=1/4(1+1.5+3.2+10)=15.7/4

解析：高响应比优先调度算法这里有些不同。这里作业一运行完毕之后，需要根据公式：优先权=（等待时间+执行时间）/执行时间，来判断下一个需要运行的作业。同样，这里的作业1的结束时间为7.5，留下作业2和作业3进行判断。根据公式计算作业2:   （7.5-7.0+1）/1=1.5

计算作业3：（7.5-7.5+0.5）/0.5=1.所以先运行作业2，作业2运行完毕后，对作业3和作业4进行判断。

作业3：（8.5-7.5+0.5）/0.5=3

作业4：（8.5-7.6+0.1）/0.1=10，所以先运行作业4，后运行作业3

#include <iostream>

using namespace std;

class JCB
{
public:
    void input();
    void output();
    void bubbleSort(int start, int len);
    void bubbleSort1(int start, int len);
    int getCount(int x);
    void swap(int x, int y);
    void makeJCB(int x);
    void makeTime(int x);
    void init();
    void printCir();
private:
    int length;
    double arriveTime[10];
    double startTime[10];
    double workTime[10];
    double finishTime[10];
    double cirTime[10];
    double dqzzTime[10];
    string name[10];
};

void JCB::input()
{
    cout << "请输入进程数量: ";
    cin >> length;
    for(int i=0; i<length; i++)
    {
        cout << "进程" << i+1 << ": " << endl;
        cout << "请输入进程名称："; cin >> name[i];
        cout << "请输入进程到达时间："; cin >> arriveTime[i];
        cout << "请输入进程运行时间："; cin >> workTime[i];
    }

}

void JCB::output()
{
    cout << endl;
            cout << "进程名称  " << "到达时间  " << "处理时间  " << "开始时间  "<< "完成时间  " << "周转时间  " << "带权周转时间  " << endl;
    for(int i=0; i<length; i++)
    {
        makeJCB(i);

        cout << name[i] << "  \t" << arriveTime[i] << "  \t" << workTime[i] << "  \t" << startTime[i] << "  \t"
        << finishTime[i] << "  \t" << cirTime[i] << "  \t" << dqzzTime[i] << "\t  " << endl;
        cout << endl;
    }
}

void JCB::bubbleSort(int start, int len)
{
    for(int i=start; i<start+len-1; i++)
        for(int j=start; j<start+len-1; j++)
            if(workTime[j] > workTime[j+1])
                swap(j,j+1);
}

void JCB::bubbleSort1(int start, int len)
{
    for(int i=start; i<start+len-1; i++)
        for(int j=start; j<start+len-1; j++)
            if(arriveTime[j] > arriveTime[j+1])
                swap(j,j+1);
}

int JCB::getCount(int x)
{
    int count = 0;
    int y = x-1;
    for(int i=x; i<length; i++)
        if(arriveTime[i] <= finishTime[y])
            count++;
    return count;
}

void JCB::swap(int x, int y)
{
    double temp;
    string temp1;
    temp = arriveTime[x]; arriveTime[x] = arriveTime[y]; arriveTime[y] = temp;
    temp = workTime[x]; workTime[x] = workTime[y]; workTime[y] = temp;
    temp1 = name[x]; name[x] = name[y]; name[y] = temp1;
}

void JCB::makeTime(int x)
{
    finishTime[x] = startTime[x] + workTime[x];
    cirTime[x] = finishTime[x] - arriveTime[x];
    dqzzTime[x] = cirTime[x] / workTime[x];
}

void JCB::printCir()
{
    double Tcir = 0;
    double Tdqzz = 0;
    for(int i=0; i<length; i++)
    {
        Tcir = Tcir + cirTime[i];
        Tdqzz = Tdqzz + dqzzTime[i];
    }
    cout << "平均周转时间：" << Tcir/length << endl;
    cout << "平均带权周转时间：" << Tdqzz/length << endl;

}

void JCB::makeJCB(int x)
{
    if(x == 0)
    {
        bubbleSort1(x,length);
        startTime[x] = arriveTime[x];
        makeTime(x);
    }
    else
    {
        int count = getCount(x);
        if(count == 0)
        {
            startTime[x] = arriveTime[x];
            makeTime(x);
        }
        else
        {
            bubbleSort(x,count);
            startTime[x] = finishTime[x-1];
            makeTime(x);
        }
    }
}

void JCB::init()
{
    for(int i=0; i<10; i++)
    {
        arriveTime[i] = 0;
        startTime[i] = 0;
        workTime[i] = 0;
        finishTime[i] = 0;
        cirTime[i] = 0;
        dqzzTime[i] = 0;
    }
}

int main()
{
    JCB A;
    A.init();
    A.input();
    A.output();
    A.printCir();
}

计算出平均周转时间和平均带权周转时间

题目：

现在已知系统中有5个进程，其到达时间和要求服务时间如表所示：
进程次序: p1–p2–p3–p4–p5, 时间片大小： 4
到达时间： [0, 1, 2, 3, 4]
要求服务时间: [6, 3, 3, 4, 6]
要求：
（1） 计算出平均周转时间；
（1） 计算出平均带权周转时间；
注意：浮点数小数点后保留2位（四舍五入）
参考答案：
平均周转时间 12.6
平均带权周转时间 2.75

"""
此程序十分不严谨
仅用于考试快速出答案
"""


N = 4
serve_time = [9,2,7,7,7]
pro = [0, 1, 2, 3, 4]

def deal_serve_time():
    ret = []
    _serve_time = serve_time.copy()
    while sum(_serve_time) > 0:
        for i in range(len(serve_time)):
            for j in range(N):
                if _serve_time[i] > 0:
                    ret.append(i)
                    _serve_time[i] -= 1
    return ret

def count_time(serve_list):
    ret = []
    serve_list_r = list(reversed(serve_list))
    for i in pro:
        lst = len(serve_list) - serve_list_r.index(i) - i
        ret.append(lst)
    return ret

def count_avg_time(time):
    return sum(time) / len(time)

def count_avg_quan_time(time):
    ret = []
    for i in range(len(time)):
        ret.append(time[i] / serve_time[i])
    return sum(ret) / len(ret)


serve_list = deal_serve_time()
time = count_time(serve_list)
avg_time = count_avg_time(time)
avg_quan_time = count_avg_quan_time(time)
print(avg_time)
print(avg_quan_time)