一个作业调度程序，采用的链式优先级队列

                      以前编的一个使用链式优先级队列的作业调度程序，也是比较简单的。

#include < iostream >
#include < assert.h >
using   namespace  std;
enum  staff ... {Manager,Supervisor,Worker} ;
struct  JobRequest                         // 员工请求类，要加入到优先级队列中
... {
    staff staffPerson;
    int jobID;
    int jobTime;
    JobRequest *next;

    JobRequest(staff person = Worker,int ID = 0,int time = 0,JobRequest *link = NULL)
    ...{
        staffPerson=person;
        jobID=ID;
        jobTime=time;
        next=link;
    }

    ~JobRequest()
    ...{}
} ;

class  PQueue                              // 链式优先级队列类
... {
private:

    JobRequest *front,*rear;

public:
    PQueue()
    ...{
        front=NULL;
        rear=NULL;
    }

    void EnQueue(staff person,int ID,int time) //入队列函数
    ...{
        if(front == NULL)
            front = rear = new JobRequest(person, ID, time, NULL);
        else
            rear = rear->next = new JobRequest(person, ID, time, NULL);
    }

    JobRequest DeQueue()             //优先级队列出队列函数
    ...{
        assert(!IsEmpty());
        JobRequest *min = front;
        JobRequest *pre = front;
        JobRequest *p = front;
        JobRequest temp;             //定义一个局部对象

        while(p->next)               //找现有队列中优先级最高的，指针pre指向它的前驱
        ...{
            if(p->next->staffPerson <= min->staffPerson)
            ...{
                min = p->next;  
                pre = p;
            }
            p = p->next;
        }

        temp = *min;               //将找到的优先级最高的对象付给临时对象
        pre->next = min->next;     //从链式队列中拆除

        if(min == front)           //如果值最小的节点是front此时min指向的位置是front->next;
                                   //此时应delete front所指向的节点
        ...{
            delete front;
            front = NULL;
        }
        else                        //否则释放min所指向的节点
        ...{
            delete min;                //释放内存
            min = NULL;                //重要
        }
        
        return temp;                //返回临时对象给调用者后析构
    
    }

    bool IsEmpty()
    ...{
        if(front == NULL)
            return true;
        else 
            return false;
    }

    ~PQueue()                      //顺次释放
    ...{
        JobRequest *p;
        while(front != NULL)
        ...{
            p = front;
            front = front->next;
            delete p;
        }
    }
} ;

main()
... {
    PQueue myQueue;                            //实例化一个优先级队列的对象

    myQueue.EnQueue(Worker, 1, 2);             //依次加入优先级队列
    myQueue.EnQueue(Supervisor, 2, 4);
    myQueue.EnQueue(Manager, 3, 3);
    myQueue.EnQueue(Manager, 4, 7);
    myQueue.EnQueue(Worker, 5, 5);
    myQueue.EnQueue(Supervisor, 6, 4);
    myQueue.EnQueue(Supervisor, 7, 6);

    int JobServices[3] = ...{0, 0, 0};             //一个记录时间的数组
    JobRequest s;
    JobRequest *p;
    
    cout<<"服务程序启动......." <<endl;
    cout<<"Manager(0)  Supervisor(1) Worker(2)"<<endl;

    while(!myQueue.IsEmpty())                  //如果队列非空的话就选择优先级高的出队列
    ...{
        s=myQueue.DeQueue();
        p=&s;

        switch(p->staffPerson)             //根据需要服务的对象计算出一类人被服务的总时间
        ...{
            case 0 : JobServices[0] += p->jobTime; break;
            case 1 : JobServices[1] += p->jobTime; break;
            case 2 : JobServices[2] += p->jobTime; break;
            default : cout<<"error!"<<endl;
        }

        cout<<p->staffPerson<<"  User'ID:"<<p->jobID<<endl;

    }

        cout<<"累计时间如下：" <<endl;
        cout <<"Manager:" <<"Usedtime:" <<JobServices[0]<<endl;
        cout <<"Supervisor:" <<"Usedtime:" <<JobServices[1]<<endl;
        cout <<"Worker:" <<"Usedtime:" <<JobServices[2]<<endl;
    
}