pcb[PCBNum];//创建进程结构体数组

在计算机科学中，进程控制块（PCB）是操作系统用于跟踪进程的数据结构。在C语言中，可以通过定义结构体来创建进程控制块数组。下面是一个简单的例子[^1]：

struct Process
{
    int processID;
    char processName[20];
    float processTime;
};

struct Process pcb[PCBNum]; //定义进程控制块数组

这个例子定义了一个包含三个成员的 `Process` 结构体，分别是进程 ID、进程名称和进程运行时间。`pcb[PCBNum]` 便是一个进程控制块数组， `PCBNum`是数组的大小。在这个数组中，每个元素都是一个 `Process` 结构体，可以使用下标来访问每个元素。

相关问题

优化下列代码：//先来先服务 #include <stdlib.h> #include <stdio.h> struct pcb{ // 定义一个结构体，里面包含的有一个进程相关的信息 char name[10]; //进程名称 (输入) float arrivetime; //到达时间 (输入) float servicetime; //服务时间 (输入) float starttime; //开始时间 float finishtime; //结束时间 float zztime; //周转时间=finishtime-arrivetime float dqzztime; //带权周转时间=zztime/servicetime }; //输入进程信息 void input(pcb *p, int N) //p为pdb数组名， N为pcb数组的元素个数 { int i; prin

下面是优化后的代码：

#include <stdlib.h>
#include <stdio.h>

struct pcb {
    char name[10];      //进程名称 (输入)
    float arrivetime;   //到达时间 (输入)
    float servicetime;  //服务时间 (输入)
    float starttime;    //开始时间  
    float finishtime;   //结束时间  
    float zztime;       //周转时间=finishtime-arrivetime
    float dqzztime;     //带权周转时间=zztime/servicetime
};

//输入进程信息
void input(pcb *p, int N) {
    int i;
    for (i = 0; i < N; i++) {
        printf("请输入第%d个进程的信息：\n", i + 1);
        printf("进程名称:");
        scanf("%s", p[i].name);
        printf("到达时间:");
        scanf("%f", &p[i].arrivetime);
        printf("服务时间:");
        scanf("%f", &p[i].servicetime);
    }
}

//先来先服务算法
void FCFS(pcb *p, int N) {
    int i;
    float sum_zztime = 0, sum_dqzztime = 0;
    p[0].starttime = p[0].arrivetime;
    p[0].finishtime = p[0].starttime + p[0].servicetime;
    p[0].zztime = p[0].finishtime - p[0].arrivetime;
    p[0].dqzztime = p[0].zztime / p[0].servicetime;
    for (i = 1; i < N; i++) {
        if (p[i].arrivetime <= p[i - 1].finishtime) {
            p[i].starttime = p[i - 1].finishtime;
        } else {
            p[i].starttime = p[i].arrivetime;
        }
        p[i].finishtime = p[i].starttime + p[i].servicetime;
        p[i].zztime = p[i].finishtime - p[i].arrivetime;
        p[i].dqzztime = p[i].zztime / p[i].servicetime;
    }
    for (i = 0; i < N; i++) {
        sum_zztime += p[i].zztime;
        sum_dqzztime += p[i].dqzztime;
    }
    printf("先来先服务算法:\n");
    printf("进程名称 到达时间 服务时间 开始时间 完成时间 周转时间 带权周转时间\n");
    for (i = 0; i < N; i++) {
        printf("%-10s %-9.2f %-9.2f %-9.2f %-9.2f %-9.2f %-9.2f\n", p[i].name, p[i].arrivetime,
               p[i].servicetime, p[i].starttime, p[i].finishtime, p[i].zztime, p[i].dqzztime);
    }
    printf("平均周转时间:%.2f\n", sum_zztime / N);
    printf("平均带权周转时间:%.2f\n", sum_dqzztime / N);
}

int main() {
    int N;
    printf("请输入进程数:");
    scanf("%d", &N);
    pcb *p = (pcb *) malloc(N * sizeof(pcb));
    input(p, N);
    FCFS(p, N);
    free(p);
    return 0;
}

主要的优化点包括：

1. 在输入函数中使用了循环，减少了代码的重复部分。
2. 在输入函数中，结构体数组名直接作为参数传递，而不是再次定义一个变量来表示。
3. 在先来先服务算法函数中，使用了更简洁的代码来计算每个进程的开始时间、结束时间、周转时间和带权周转时间。
4. 在输出结果时，使用了更合理的格式化字符串，使输出结果更加美观。
5. 在主函数中，使用动态内存分配来申请结构体数组的内存，更加灵活。

struct PCB { char name; //进程名 double arrivalTime; //进程到达时间 double serviceTime; //进程要求服务时间 double startTime; //进程开始执行时间 double needServiceTime; //进程还需占用CPU时间 double endTime; //进程执行完成时间 double priority; //进程优先级 double turnaroundTime; //进程周转时间 double weightTurnarounfTime; //进程带权周转时间 string status; //进程状态 }; 结构体为以上PCB的最短剩余时间优先算法C语言实现

//头文件
#include<stdio.h>
#include<string.h>

//定义进程控制块的结构体
struct PCB {
char name; //进程名
double arrivalTime; //进程到达时间
double serviceTime; //进程要求服务时间
double startTime; //进程开始执行时间
double needServiceTime; //进程还需占用CPU时间
double endTime; //进程执行完成时间
double priority; //进程优先级
double turnaroundTime; //进程周转时间
double weightTurnarounfTime; //进程带权周转时间
char status[20]; //进程状态
};

//函数声明
void SJF(struct PCB[], int);
void display(struct PCB);

int main()
{
int n; //进程数量
printf("请输入进程数量：");
scanf("%d", &n);

struct PCB pcb[n]; //定义PCB数组

//输入每个进程的信息
for(int i=0;i<n;i++) {
printf("请输入第%d个进程的信息：\n", i+1);
printf("进程名：");
scanf("%s", &pcb[i].name);
printf("到达时间：");
scanf("%lf", &pcb[i].arrivalTime);
printf("要求服务时间：");
scanf("%lf", &pcb[i].serviceTime);
pcb[i].needServiceTime = pcb[i].serviceTime; //初始化还需占用CPU时间
printf("优先级：");
scanf("%lf", &pcb[i].priority);
strcpy(pcb[i].status, "未执行"); //初始化状态
printf("\n");
}

SJF(pcb, n); //调用最短剩余时间优先算法

//输出每个进程的信息
printf("进程名 到达时间 要求服务时间 开始执行时间 还需占用CPU时间 执行完成时间 优先级 周转时间 带权周转时间 状态\n");
for(int i=0;i<n;i++) {
display(pcb[i]);
}

return 0;
}

//最短剩余时间优先算法
void SJF(struct PCB pcb[], int n)
{
double currentTime = pcb[0].arrivalTime; //当前时间初始化为第一个进程到达时间
int count = 0; //已完成进程数量

while(count < n) {
int shortest = -1; //最短剩余时间的进程下标
double shortestTime = 999999; //最短剩余时间

//找到最短剩余时间的进程
for(int i=0;i<n;i++) {
if(pcb[i].status[0] != 'F' && pcb[i].arrivalTime <= currentTime && pcb[i].needServiceTime < shortestTime) {
shortestTime = pcb[i].needServiceTime;
shortest = i;
}
}

//更新进程信息
pcb[shortest].status[0] = 'E'; //标志为执行
pcb[shortest].startTime = currentTime;
pcb[shortest].endTime = currentTime + pcb[shortest].needServiceTime;
pcb[shortest].turnaroundTime = pcb[shortest].endTime - pcb[shortest].arrivalTime;
pcb[shortest].weightTurnarounfTime = pcb[shortest].turnaroundTime / pcb[shortest].serviceTime;
pcb[shortest].needServiceTime = 0;
currentTime = pcb[shortest].endTime;
count++;
}
}

//输出进程信息的函数
void display(struct PCB pcb)
{
printf("%c\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%.2lf\t%s\n", pcb.name, pcb.arrivalTime, pcb.serviceTime, pcb.startTime, pcb.needServiceTime, pcb.endTime, pcb.priority, pcb.turnaroundTime, pcb.weightTurnarounfTime, pcb.status);
}