操作系统实验：进程调度

 实验代码部分：

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int MaxSize=20;
template <class T >
struct Node
{
    T cpudata;
    T pdata;
    T rdata;
    T numdata;
    Node<T> *next;
};
template <class T>
class LinkList
{
public:
    LinkList();     //无参构造函数
    LinkList(int n,T a[ ],T b[ ],T c[], T e[]);       //尾接法构造函数,轮转法
    LinkList(int n,T a[ ],T b[ ],T c[]);       //尾接法构造函数,优先权法
    ~LinkList( );          //析构函数为空
    int GetLength();//求顺序表的长度
    T PowDelete();
    T TimeDelete(int n);
    Node<T> *Getfirst();
    void SetFirst(Node<T> *p){first=p;} //置头指针
private:
    Node<T> *first;
    T numdata[MaxSize];
    T cpudata[MaxSize];
    T pdata[MaxSize];
    T rdata[MaxSize];
    int length;
};
//无参构造函数
template <class T>
LinkList<T>::LinkList()
{
    first=new Node<T>;
    first->next=first;
}
//优先权法
template<class T>
T LinkList<T>::PowDelete()
{
    Node <T> *p=first;
    Node<T>*q;
    int l=length;
    while(l>0)
    {
        p->cpudata=p->cpudata-1;
        p->pdata=p->pdata-3;
        if(p->cpudata==0)
        {
            l=l-1;
            cout<<"第"<<p->numdata<<"个进程完成运行"<<endl;
            q->next=p->next;
            p=q;

        }
        else
        {
            cout<<"第"<<p->numdata<<"个进程剩余所需CPU时间为"<<p->cpudata<<endl;
            cout<<"第"<<p->numdata<<"个进程目前的优先权为"<<p->pdata<<endl;
        }
        q=p;
        p=p->next;
        cout<<"------------"<<endl;
    }
    cout<<"进程已完成运行"<<endl;
    return 0;
}
//轮转法
template<class T>
T LinkList<T>::TimeDelete(int n)
{
    Node <T> *p=first;
    Node<T>*q;
    int l=n;
    while(l>0)
    {
        p->cpudata=p->cpudata-1;
        p->pdata=p->pdata+1;
        if(p->cpudata==0)
        {
            cout<<"第"<<p->numdata<<"个进程完成运行"<<endl;
            l=l-1;
            q->next=p->next;
            p=q;
        }
        else
        {
            cout<<"第"<<p->numdata<<"个进程剩余所需CPU时间片为"<<p->cpudata<<endl;
            cout<<"第"<<p->numdata<<"个进程目前已占用时间片为"<<p->pdata<<endl;
            if(p->pdata==p->rdata)
            {
                p->pdata=0;
            }

        }
        q=p;
        p=p->next;
        cout<<"------------"<<endl;
    }
    cout<<"进程已完成运行"<<endl;
    return 0;
}
//求单链表长度
template <class T>
int LinkList<T>::GetLength()
{
    Node<T> *p=first;
    int j=1;
    while(p->next!=first)
    {
        p=p->next;
        j++;
    }
    length=j;
    cout<<"进程个数为"<<length<<endl;
    return 0;
}
//后接方式建单链表
template<class T>
LinkList<T>::LinkList(int n,T a[],T b[],T c[])//a:cpu时间；b:优先权；c:第几个进程
{
    first=new Node<T>;
    first->cpudata=a[0];
    first->pdata=b[0];
    first->numdata=c[0];
    Node<T> *r=first,*s;
    for(int i=1; i<n;i++)
    {
        s=new Node<T>;
        s->cpudata=a[i];
        s->pdata=b[i];
        s->numdata=c[i];
        r->next=s;
        r=s;
    }
    r->next=first;
}
template<class T>
LinkList<T>::LinkList(int n,T a[],T b[],T c[],T e[])//后接，轮转法,每个进程的轮转时间片数，生成进程所需要的时间片数，第几个进程，占用的时间片数
{
    first=new Node<T>;
    first->rdata=a[0];
    first->cpudata=b[0];
    first->numdata=c[0];
    first->pdata=e[0];
    Node<T> *r=first,*s;
    for(int i=1; i<n;i++)
    {
        s=new Node<T>;
        s->rdata=a[i];
        s->cpudata=b[i];
        s->numdata=c[i];
        s->pdata=e[i];
        r->next=s;
        r=s;
    }
    r->next=first;
}
//析构函数释放单链表中的结点储存空间
template <class T>
LinkList<T>::~LinkList()
{
    Node<T> *p=first;
    while(p&&length>0)
    {
        Node<T> *q=p;
        p=p->next;
        delete q;
        length--;
    }
}

int main()
{
    srand((int)time(0));
    while(1){
        int n=0,m=0,i=0;
        int a[10];
        int b[10];
        int c[10];

        cout<<"请输入进程个数:"<<endl;
        cin>>n;
        cout<<"请输入调度方法的选择（若选择优先权法则输入1，若选择轮转法请输入0）:"<<endl;
        cin>>m;
        if(m==1)
        {
            for(i=0;i<n;i++)
            {
                a[i]=rand()%20+1;//随机生成cpu所需的时间
                b[i]=rand()%n+1;//随机生成优先权(默认数值越大，优先权越大，默认先生成的排在队列前面)
                c[i]=i+1;//第几个进程
                cout<<"第"<<c[i]<<"个进程所需时间为："<<a[i]<<"; 优先权为："<<b[i]<<endl;
            }
            //将所有进程按优先权排序
            for(i=0;i<n;i++)
            {
                for(int j=i+1;j<n;j++)
                {
                    if(b[j]>b[i])
                    {
                        int t=b[j];
                        b[j]=b[i];
                        b[i]=t;

                        t=a[j];
                        a[j]=a[i];
                        a[i]=t;

                        t=c[j];
                        c[j]=c[i];
                        c[i]=t;
                    }
                }
            }
            LinkList <int> d(n,a,b,c);//后接，生成链表
            d.GetLength();
            d.PowDelete();
        }
        else if(m==0)
        {
            int time[10];
            for(i=0;i<n;i++)
            {
                a[i]=rand()%4+1;//随机产生每个进程的轮转时间片数
                b[i]=rand()%20+1;//随机生成进程所需要的时间片数
                c[i]=i+1;//第几个进程
                time[i]=0;//占用的时间片数
                cout<<"第"<<c[i]<<"个进程随机产生的轮转时间片数为："<<a[i]<<"; 随机生成的时间片数为："<<b[i]<<endl;

            }
            LinkList <int> d(n,a,b,c,time);//生成链表
            d.GetLength();
            d.TimeDelete(n);
        }
    }
//    system("pause");
    return 0;

}