操作系统课程设计之进程调度源代码六种调度算法 c++

#include
#include
#include
#include
#include
using namespace std;
struct node
{
    int num;            ///序号
    char name[10];      ///进程名
    int Gen_time;       ///产生时间
    double Ser_time;    ///要求服务时间
    int Pty;            ///优先级priority
    char vis;           ///进程状态R表示就绪，E表示结束
    int ends;           ///完成时间
    double t_time;      ///周转时间
    double rt_time;     ///带权周转时间
} p[1000]pc[1000]p1[1000]
p2[1000]p3[1000]p4[1000]p5[1000];
///pc用于记录时间片轮转调度的进程数据，p1可抢占式，p2不可抢占式
///p3短进程优先调度，p4先来先服务，p5高响应比优先
int process_n;      ///存放进程的时间片
int number;         ///出入的进程个数
struct D_value
{
    int sub;
    int flage;
}s[1000];///针对时间片轮转算法，记录进程产生差值和是否被处理过一次
void Init（node m[]node n[]）    ///初始化基本数据
{
    for（int i=0; i    {
        m[i].num=n[i].num;
        strcpy（m[i].namen[i].name）;
        m[i].Gen_time=n[i].Gen_time;
        m[i].Ser_time=n[i].Ser_time;
        m[i].Pty=n[i].Pty;
        m[i].vis=n[i].vis;
    }
}
void print（int by_order[]int knode q[]）   ///输出进程执行结果
{
    printf（“%-16s%-16s%-16s%-16s%-16s%-16s%-16s\n“
           “进程序列号““进程名““产生时间““要求服务时间““完成时间“
           “周转时间““带权周转时间“）;
    double sum1=0sum2=0;
    for（int i=0; i    {
        printf（“%-8d\t%-8s\t%-8d\t%-8.2lf\t%-8d\t%-8.2lf\t%-8.2lf\n“
               q[i].numq[i].nameq[i].Gen_timeq[i].Ser_timeq[i].ends
               q[i].t_timeq[i].rt_time）;
        sum1+=q[i].t_time;
        sum2+=q[i].rt_time;
    }
    cout<    printf（“平均周转时间为：%.2lf 平均带权周转时间为：%.2lf\n\n“sum1/numbersum2/number）;
    printf（“各进程执行顺序为：\n“）;
    for（int i=0; i    {
        if（i==0）
            printf（“%d “by_order[i]）;
        else if（i!=0&&by_order[i]!=by_order[i-1]）
            printf（“%d “by_order[i]）;
    }
    printf（“\n“）;
    return;
}
bool cmp（node anode b）  ///按照进程的序号排列
{
    return a.num}
void Time_Circular（）    ///时间片轮转调度
{
    printf（“输入时间片：“）;
    cin>>process_n;
    int sum=0run_sum=0;
    Init（pcp）;     ///初始化
    memset（s0sizeof（s））;
    for（int i=0; i    {
        if（i!=0）
            s[i].sub=p[i].Gen_time-p[i-1].Gen_time;
        sum+=p[i].Ser_time;
    }
    int cnt=0k=0;
    int by_order[sum];  ///记录进程执行的顺序。
    memset（by_order0sizeof（by_order））;    ///初始化
    node q;             ///临时存储出队列的进程
    queueQQ1;    ///Q存储为执行完成的进程，Q1存储执行完成的进程
    Q.push（pc[0]）;
    for（int i=1;i    {
        if（s[i].sub<=process_n）
        {///将进程产生的间隔差值与时间片比较，分为两种情况，小于等于和大于
            Q.push（pc[i]）;
            s[i].flage=1;
        }
        else
            break;
    }
    int i=0;
    while（!Q.empty（））
    {
        q=Q.front（）;
        Q.pop（）;
        if（q.vis==‘R‘&&q.Gen_time<=i）
        {
            by_order[k++]=q.num;
            if（process_n<=q.Ser_time）///剩余要求服务时间大于等于时间片
            {
                run_sum=run_sum