设计一个按优先数调度算法实现处理器调度的程序。

（操作系统） 设计一个按优先数调度算法实现处理器调度的程序。

（Tip：代码仅供参考，如有错误，欢迎指正。程序采用c++，如果使用Linux运行可根据需要改为c或者直接运行c++。注释只是随手写的，记录一下思考过程而已，看不懂自己悟，自己csdn，不要问别人。为了防止改代码的麻烦，博主就直接把（8）也做了，根据需要可自行修改。）

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪8080”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。本实验由于为了检查的方便，优先数和运行时间采用下表中的数值。
(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：
队首标志

(4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：
优先数-1
要求运行时间-1
来模拟进程的一次运行。
提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。
(5) 进程运行一次后，若要求运行时间0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。
(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。
(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
选作部分
(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

废话不多说，直接上代码，想知道结果对不对，自己去运行。

#include <iostream>
#include <queue>

using namespace std;

#define OK 1
#define ERROR 0

typedef int Status;
typedef string PROC_STATE;
int length = 5;

typedef struct _proc {/*进程结构体*/
    //char henu[1912];/*进程名*/
    string name;/*进程名*/
    int run_time; /*要求运行总时间*/
    int alloc_time; /*已经运行时间*/
    int rel_time;/*还需要的运行时间*/
    int pri;/*优先级：时间片调度中未使用*/
    PROC_STATE state;/*进程状态*/
    struct _proc* next;
    friend  bool operator<(const _proc& a, const _proc& b) {
        return  a.pri < b.pri;
    }//排序操作，按照优先级的从大到小，形成小根堆
} PROC, * PROCPtr;

typedef struct {
    PROCPtr front;
    PROCPtr rear;
} LinkQueue;

Status InitQueue(LinkQueue& Q) { //链队初始化,构造一个空队列Q
    Q.front = Q.rear = new PROC;
    Q.front->next = NULL;
    cout << "->初始化创建链队完成!" << endl;
    return OK;
}

Status EnQueue(LinkQueue& Q, string name, int run_time, int alloc_time, int rel_time, int pri, PROC_STATE state) { //入队
    PROCPtr p;
    p = new PROC;
    p->name = name;
    p->run_time = run_time;
    p->alloc_time = alloc_time;
    p->rel_time = rel_time;
    p->pri = pri;
    p->state = state;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    cout << "->数据元素入队完成!" << endl;
    return OK;
}

void SortQueue(LinkQueue& Q) {
    priority_queue<_proc>M;//对队列进行从大到小的排序，形成小根堆
    PROC s;
    PROCPtr t = Q.front->next;
    do {//先将Ready状态的进程取出，按照优先级进行排序
        if (t->state == "End") {
            break;
        }
        s.name = t->name;
        s.run_time = t->run_time;
        s.alloc_time = t->alloc_time;
        s.rel_time = t->rel_time;
        s.pri = t->pri;
        s.state = t->state;
        M.push(s);
        t = t->next;
    } while (t != NULL);
    t = Q.front->next;
    while (!M.empty()) {//将排序好的进程，放入队列中
        t->name = M.top().name;
        t->run_time = M.top().run_time;
        t->alloc_time = M.top().alloc_time;
        t->rel_time = M.top().rel_time;
        t->pri = M.top().pri;
        t->state = M.top().state;

        M.pop();
        t = t->next;
    }//经过该过程，原来的进程结构体指针顺序并未发生改变，只是将结构体的数值进行了替换。

}

void PrintQueue(LinkQueue Q) {//打印输出
    if (Q.front == Q.rear) {
        cout << "->队列当前为空，无数据元素打印输出!" << endl;
    }
    else {
        PROCPtr p;
        p = Q.front->next;
        cout << "<--------------------------------------------->" << endl;
        cout << "进程名\t" << "总时间\t" << "运行\t" << "剩余\t" << "优先级\t" << "状态\t" << endl;
        do {
            cout << p->name << "\t" << p->run_time << "\t" << p->alloc_time << "\t" << p->rel_time << "\t" << p->pri << "\t" << p->state << "\t" << endl;
            p = p->next;
        } while (p != NULL);
    }
}

void Running(LinkQueue& Q) {//开始运行
    PrintQueue(Q);
    SortQueue(Q);
    while (Q.front->next->state != "End") {
        PROCPtr t = Q.front->next;
        t->pri--;
        t->alloc_time++;
        t->rel_time = t->run_time - t->alloc_time;
        if (t->rel_time == 0) {//当进程结束时，将该进程放到队尾
            t->state = "End";
            Q.rear->next = t;
            Q.rear = t;
            Q.front->next = t->next;
            t->next = NULL;
        }
        SortQueue(Q);
        PrintQueue(Q);
    }

}

int main() {
    LinkQueue Q;
    InitQueue(Q);

    cout << "请依次输入五组程序控制块PCB：(进程名-总时间-优先级)" << endl;

    string n;/*进程名*/
    int rut = 0; /*要求运行总时间*/
    int alt = 0; /*已经运行时间*/
    int ret = 0;/*还需要的运行时间*/
    int pri = 0;/*优先级：时间片调度中未使用*/
    PROC_STATE state = "Ready";/*进程状态*/

    while (length--) {
        cin >> n >> rut >> pri;
        ret = rut;
        EnQueue(Q, n, rut, alt, ret, pri, state);
    }

    Running(Q);

    return 0;
}
/*这里是测试数据
P1 2 1
P2 3 5
P3 1 3
P4 2 4
P5 4 2
*/