FCFS、RR、SPF、PSA、DPSA算法代码---C语言

最新推荐文章于 2024-07-20 01:54:45 发布
最新推荐文章于 2024-07-20 01:54:45 发布
阅读量5k 收藏 57
点赞数 11
文章标签： 操作系统 算法 数据结构 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhhhaaam/article/details/105499028
版权

直接看代码

----------------------操作系统作业
1.FCFS先入先出
2.RR时间片轮转
3.SPF短进程优先即最短处理机运行期优先
4.PSA优先级调度算法
5.DPSA动态优先级调度算法

#pragma once//常用的C/C++预处理指令，只要在头文件的最开始加入这条预处理指令，就能够保证头文件只被编译一次。
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>//size_t（库变量） NULL(宏) 
#include <stdlib.h>//size_t free 
#include <stdbool.h>//定义了 bool 代表 _Bool，true 代表 1，false 代表 0
typedef struct PCB {
	char name;                 //进程名
	int ArrivalTime;           //到达时间
	int ServiceTime;           //服务时间
	int StartTime;             //开始时间
	int FinishTime;            //完成时间
    int ResidualTime;          //剩余服务时间
	double WholeTime;          //周转时间
	double weightWholeTime;    //带权周转时间
    int Priority;              //优先级
}PCB;
typedef PCB DataType;
typedef struct Node {
	DataType data;
	struct Node *next;//队列的存储结构 --共用 
}Node;
typedef struct Queue {//链队列1 的存储结构 
	Node *front;
	Node *rear;
	size_t size;			//队列中有几个元素
}Queue;


typedef struct linkList {//队列2的存储结构 
    Node *head;
    Node *tail;
    size_t size;
}linkList;

void QueueInit(Queue *pqueue) {	//	队列1  队列初始化
	assert(pqueue != NULL);
	pqueue->front = NULL;
	pqueue->rear = NULL;
	pqueue->size = 0;
}

void QueueDestroy(Queue *pqueue)//队列1 把队列删除 
{
	Node *cur = NULL;
	Node *del = NULL;
	assert(pqueue != NULL);
	if (pqueue->front == NULL) {
		return;
	}
	cur = pqueue->front;
	while (cur != NULL) {
		del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
}

Node *CreatNode(DataType data)//创造一个新节点 --共用 
{
	Node *ret = (Node *)malloc(sizeof(Node));
	if (ret == NULL) {
		exit(0);
	}
	ret->data = data;
	ret->next = NULL;
	return ret;
}

void QueuePush(Queue *pqueue, DataType data)//队列1 增加队列 
{
	assert(pqueue != NULL);
	Node *temp = CreatNode(data);//一个新的结点 
	if (pqueue->front == NULL) {
		pqueue->front = temp;
		pqueue->rear = temp;
		//pqueue->rear = pqueue->front = temp;
		++pqueue->size;//大小加一 
	}
	else {
		pqueue->rear->next = temp;
		pqueue->rear = pqueue->rear->next;
		//pqueue->rear = temp;
		++pqueue->size;
	}
}

void QueuePop(Queue *pqueue)//队列1 删除队列头指针指向的队列元素 
{
	assert(pqueue != NULL);
	Node *del = NULL;
	assert(pqueue != NULL);
	if (pqueue->front == NULL) {
		return;
	}
	del = pqueue->front;
	pqueue->front = pqueue->front->next;
	free(del);
	del = NULL;
	++pqueue->size;
    
}

Node *QueueTop(Queue *pqueue)//队列1队头指针 
{
	return pqueue->front;
}


bool QueueEmpty(const Queue *pqueue)//队列1判空 
{
	return pqueue->front == NULL;
}

size_t QueueSize(const Queue *pqueue)//队列1的长度 
{
    return pqueue->size;
}




void linkListInitialize(linkList *plinklist)//队列2的初始化 
{
    assert(plinklist != NULL);
    plinklist->head = NULL;
    plinklist->tail = NULL;
    plinklist->size = 0;    

}

void linkListDestroy(linkList *plinklist)//队列2的删除 
{
	Node *cur = NULL;
	Node *del = NULL;
	assert(plinklist != NULL);
	if (plinklist->head == NULL) {
		return;
	}
	cur = plinklist->head;
	while (cur != NULL) {
		del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
}

void linkListPushBack(linkList *plinklist, DataType data)//与队列2的入队 
{
	assert(plinklist != NULL);
	Node *temp = CreatNode(data);
	if (plinklist->head == NULL) {
		plinklist->head = temp;
		plinklist->tail = temp;
		//pqueue->rear = pqueue->front = temp;
		++plinklist->size;
	}
	else {
		plinklist->tail->next = temp;
		plinklist->tail = plinklist->tail->next;
		//pqueue->rear = temp;
		++plinklist->size;
	}
}

void linkListErase(linkList *plinklist, Node *pnode)//队列2 把结点pnode找到并且删除 （头开始删除） 
{
	Node *cur = NULL;
	assert(plinklist != NULL);
	cur = plinklist->head;
	if ((plinklist->head) == NULL) {
		return;
	}
    if ((plinklist->head) == pnode) {//刚好为队头元素 
        plinklist->head = pnode->next;
        free(pnode);
        pnode = NULL;
        --(plinklist->size);
        return;
    }
    while(cur != NULL) {
        if (cur->next == pnode) {
            cur->next = pnode->next;
            free(pnode);
            pnode = NULL;
            --(plinklist->size);
            break;
        }
        cur = cur->next;
    } 
}

bool linkListEmpty(const linkList *plinkList)//队列2 判空 
{
	return plinkList->head == NULL;
}

size_t linkListSize(const linkList *plinklist)//队列2的长度 
{
    return plinklist->size;
}
Node *Min(linkList *plinklist,int size)//找到满足条件的结点 
{
	Node *p,*q;
	//int flagnum=0;
	int Amin,Smin;
	p=plinklist->head;
	q=plinklist->head;
//	flag=plinklist->head;
	Amin=p->data.ArrivalTime;
	Smin=p->data.ServiceTime;
	while(size>0)
	{
		if(p->data.ArrivalTime<Amin)
		{
			Amin=p->data.ArrivalTime;
		
			q=p;
			
		}
		if(p->data.ArrivalTime==Amin)
		{
				if(p->data.ServiceTime<Smin)
				q=p;
		}
		
		p=p->next;
		size--;
		
	}
	return q;
}
Node *linklistTop(linkList *plinklist)//队列2队头指针 
{
	return plinklist->head;
}

算法部分

void FCFS(Queue *pqueue, PCB pcbs[], int size)
{
    int pcbnumber = size;//
	int time = 0;
	//
	//  |_______|_______|_______|_______|_______|_______|_______|_______|___
	//	0       1       2       3       4       5       6       7       8 

	while (1) {                                                          // e.g.  
		//等待进程
        for (int i = 0; i < size; i++) {
            if (pcbs[i].ArrivalTime == time) {//谁先到达谁就先开始 
                QueuePush(pqueue, pcbs[i]);
			    printf("PCB %c ARRIVAL TIME IS %d\n", pcbs[i].name, time);
                pcbnumber--;
            }
        }
        if (QueueEmpty(pqueue) && pcbnumber == 0) {//已经装满 
			printf("进程执行完毕！\n");
			break;
		}
        //
        //显示时间
//		printf("time is %d \n", time);

		//执行进程
        if (!QueueEmpty(pqueue) && QueueTop(pqueue)->data.ResidualTime == 0) {
            printf("PCB %c FINISH TIME IS %d\n", QueueTop(pqueue)->data.name, time);
            QueuePop(pqueue);//头指针指向的结点删除，指针向上走一个 
        }

        if (!QueueEmpty(pqueue)) {
            QueueTop(pqueue)->data.ResidualTime--;
        }

		time++;
       // sleep(1);
	}
}

void RR(Queue *pqueue, PCB pcbs[], int size)
{ 
	//这里是时间片的大小
	int q = 0;
    printf("please input q:");
    scanf("%d", &q);
	//这个表示本次时间片q剩下多少
	int lessq = 0;
    int pcbnumber = size;
	//表示本进程还需要的服务时间
	int time = 0;
	//
	//  |_______|_______|_______|_______|_______|_______|_______|_______|___
	//	0       1       2       3       4       5       6       7       8 

	while (1) {
		//等待进程
        for (int i = 0; i < size; i++) {
            if (pcbs[i].ArrivalTime == time) {
                QueuePush(pqueue, pcbs[i]);                
                printf("PCB %c ARRIVAL TIME IS %d\n", pcbs[i].name, time);
                pcbnumber--;                
            }
        }
        if (QueueEmpty(pqueue) && pcbnumber == 0) {
			printf("进程执行完毕！\n");
			break;
		}
        //
        //
		//执行进程
        if (lessq == 0){//时间片用完的两种情况 
            if (!QueueEmpty(pqueue) && QueueTop(pqueue)->data.ResidualTime == 0) {//时间片刚好与服务时间相同，使得剩余服务时间为0 
                printf("PCB1 %c FINISH TIME IS %d\n", QueueTop(pqueue)->data.name, time);
                QueuePop(pqueue);
            }
            else {
                if (!QueueEmpty(pqueue) && 
                    QueueTop(pqueue)->data.ServiceTime != //需要的时间比时间片多 ，还需要时间片 
                    QueueTop(pqueue)->data.ResidualTime){
                    pqueue->rear->next = pqueue->front;
                    pqueue->rear = pqueue->rear->next;
                    pqueue->front = pqueue->front->next;
                    pqueue->rear->next = NULL;//把为指针指向时间片刚用完的结点，头指针指向下一个结点  NULL：说明尾指针指向为空，不是循环队列 
                }
            }
            lessq = q;//为新一轮赋予时间片 
		}
		else {
            if (!QueueEmpty(pqueue) && QueueTop(pqueue)->data.ResidualTime == 0) {//需要的时间比时间片少，时间片没用完就完成了 
                printf("PCB %c FINISH TIME IS %d\n", QueueTop(pqueue)->data.name, time);
                QueuePop(pqueue);
                lessq = q;//新的一轮 
            }
        }
        if (!QueueEmpty(pqueue)) {
            QueueTop(pqueue)->data.ResidualTime--;//a4 3/a2 1/b2 1/a0/b0
        }
        lessq--;//1 0/1 0/1 0/1/1
		time++;//1 2 3 4 5 6 7 8
        //sleep(1);
	}
}

//请补充这里的程序 SPF:短进程优先 ，短：进程的运行时间 
//算法思路:先到达的进程先执行，要是同时到达，选择服务时间比较少的一方，实现短作业优先 
void SPF(linkList *plinklist, PCB pcbs[], int size)
{
	int time=0;
	Node *p; 
	int pcbnumber= size;
	for (int i = 0; i < pcbnumber; i++) {//把所有的值都入队列 
            linkListPushBack(plinklist, pcbs[i]);
			printf("PCB %c ARRIVAL TIME IS %d\n", pcbs[i].name, pcbs[i].ArrivalTime);
    }
    pcbnumber=0;//已经装满 
	while (1) 
	 {  //运行过程                                                	
			p=Min(plinklist,linkListSize(plinklist));
		while(1)
		{
			if (!linkListEmpty(plinklist) && p->data.ResidualTime == 0) 
			{ 
                printf("PCB %c FINISH TIME IS %d\n", p->data.name, time);
                linkListErase(plinklist,p);//删除p指定的结点 
                break;
            }
		p->data.ResidualTime--;
		time++;	
		}	
		
	}
	/*if(linkListSize(plinklist)==1)
			{
				time+=linklistTop(plinklist)->data.ServiceTime;
				printf("PCB %c FINISH TIME IS %d\n",linklistTop(plinklist)->data.name, time);
				linkListDestroy(plinklist);
			}*/
 if (linkListEmpty(plinklist) && pcbnumber == 0) {
			printf("进程执行完毕！\n");
		
}
}


void PSA(linkList *plinklist, PCB pcbs[], int size)
{

	int pcbid = 0;
    int pcbnumber = size;
	int time = 0;
    Node *curnode = NULL;
    Node *minnode = NULL;
    //
	//  |_______|_______|_______|_______|_______|_______|_______|_______|___
    //	0       1       2       3       4       5       6       7       8 
    while (1) {
        //等待进程
        for (int i = 0; i < size; i++) {
            if (pcbs[i].ArrivalTime == time) {
                linkListPushBack(plinklist, pcbs[i]);
                //       printf("QueueTop(pqueue)->next == %p\n", QueueTop(pqueue)->next);
                printf("PCB %c ARRIVAL TIME IS %d\n", pcbs[i].name, time);
                pcbnumber--;
                //	    printf("pcbnumber == %d\n", pcbnumber);
            }
        }

        if (linkListEmpty(plinklist) && pcbnumber == 0) {
			printf("进程执行完毕！\n");
			break;
		}
//		printf("time is %d \n", time);
        //
		//执行进程
        //
        if (minnode != NULL && (minnode->data).ResidualTime == 0) {
            printf("PCB %c FINISH TIME IS %d\n", (minnode->data).name, time);
            linkListErase(plinklist, minnode);
            minnode = NULL;
        }
        
        if (!linkListEmpty(plinklist) && minnode == NULL) {
            minnode = NULL;
            curnode = plinklist->head;
            while(curnode != NULL) {
                if (minnode == NULL || curnode->data.Priority < minnode->data.Priority) {
                    minnode = curnode;
                }
                curnode = curnode->next;
            }
        }        


        if (minnode != NULL) {
            --(minnode->data).ResidualTime;
        }
        
		time++;
       // sleep(1);
    }
}


void DPSA(linkList *plinklist, PCB pcbs[], int size)
{

	int pcbid = 0;
    int pcbnumber = size;
	int time = 0;
    Node *curnode = NULL;
    Node *minnode = NULL;
    //
	//  |_______|_______|_______|_______|_______|_______|_______|_______|___
    //	0       1       2       3       4       5       6       7       8 
    while (1) {
        //等待进程
        for (int i = 0; i < size; i++) {
            if (pcbs[i].ArrivalTime == time) {
                linkListPushBack(plinklist, pcbs[i]);                
                printf("PCB %c ARRIVAL TIME IS %d\n", pcbs[i].name, time);
                pcbnumber--;                
            }
        }
		//执行进程
        if (linkListEmpty(plinklist) && pcbnumber == 0) {
			printf("进程执行完毕！\n");
			break;
		}
        if (minnode != NULL && (minnode->data).ResidualTime == 0) {
            printf("PCB %c FINISH TIME IS %d\n", (minnode->data).name, time);
            linkListErase(plinklist, minnode);
            minnode = NULL;
        }
        
        if (!linkListEmpty(plinklist)) {
            minnode = NULL;
            curnode = plinklist->head;
            while(curnode != NULL) {
                if (minnode == NULL || curnode->data.Priority < minnode->data.Priority) {
                    minnode = curnode;
                }
                curnode = curnode->next;
            }
        }        


        if (minnode != NULL) {
            --(minnode->data).ResidualTime;
            ++(minnode->data.Priority);
            printf("PCB %c IS DO\n", (minnode->data).name);
        }
        curnode = plinklist->head;
        while(curnode != NULL) {
            if (curnode == minnode) {
                printf("%c priority ==  %d   ", curnode->data.name , curnode->data.Priority);
                curnode = curnode->next;
                continue;
            }
            (curnode->data.Priority) = (curnode->data.Priority - 1) > 0 ? (curnode->data.Priority) - 1 : 0;
            printf("%c priority ==  %d   ", curnode->data.name , curnode->data.Priority);
            curnode = curnode->next;
        }
        printf("\n");
		time++;       
    }
}


int main()
{
    int processnumber = 0;
	Queue queue;
    linkList linklist;
 // char name;
 // int ArrivalTime;        //到达时间
 // int ServiceTime;        //服务时间
 // int StartTime;          //开始时间
 // int FinishTime;         //完成时间
 // int ResidualTime;       //剩余服务时间
 // double WholeTime;          //周转时间
 // double weightWholeTime;    //带权周转时间
 // int Priority;           //优先级
   // PCB pcbs[] = {p1};
    printf("please input process number: ");
    scanf("%d", &processnumber);//pcb的内存和processnumber相同 
    PCB *pcbs = (PCB *) malloc (sizeof(PCB) * processnumber);
    memset(pcbs, 0, sizeof(PCB) * processnumber);// C 库函数 void *memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
    for (int i = 0; i < processnumber; i++) {
        printf("process->name: ");
        //这里有坑 ：
        //  可以用 scanf(" %c")    //   %c 前面加一个空格
        //  或者在上一行加一个getchar()
        //  getchar();
        scanf(" %c",&(pcbs[i].name));
        printf("process->ArricalTime: ");//pcb[[name,arrivaltime,servicetime,priority],[],[]......[]] processnumber个 
        scanf("%d",&(pcbs[i].ArrivalTime));
        printf("process->ServiceTime: ");
        scanf("%d",&(pcbs[i].ServiceTime));
        pcbs[i].ResidualTime = pcbs[i].ServiceTime;//！！！！！ 
        printf("process->Priority: ");
        scanf("%d",&(pcbs[i].Priority));
    }
	int input = 0;
	QueueInit(&queue); 
    linkListInitialize(&linklist);//初始化空的链队列
	printf("1. FCFS   2.RR   3.SPF   4.PSA   5.DPSA\n");
	printf("Please input number: ");
	scanf("%d", &input);
	switch (input)
	{
	case 1:
		FCFS(&queue, pcbs, processnumber); //先入先出 
		break;
	case 2:
		RR(&queue, pcbs, processnumber);  //时间片轮转 
		break;
	case 3:
       SPF(&linklist, pcbs, processnumber); //短进程优先即最短处理机运行期优先 
		break;
	case 4:
        PSA(&linklist, pcbs, processnumber); //优先级调度算法 
		break;
	case 5:
        DPSA(&linklist, pcbs, processnumber); //动态优先级调度算法 
		break;
	default:
		break;
	}
    linkListDestroy(&linklist);
	QueueDestroy(&queue);
	return 0;
}

简单的注释，有数据结构基础的，应该都看得懂，如有错误，请留言指出

HMCBigData
关注
  • 11
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
psa优先调度算法的c语言,FCFS、SJF、PSA、RR、MFS作业调度C语言实现
weixin_31290291的博客
05-24 1296
优化后此代码使用vs编辑器编写，其中使用到头文件的引用下面有源码可以直接复制使用，另外底面有源码文件链接代码不符条件的bug，请直接评论指出，会尽快修改，合作愉快2018/11/28 修复总时间无法到达到达时间修复进程到达时间相同#define _CRT_SECURE_NO_WARNINGS#define NUMBER 5#include #include char process_name[NU...
FCFS先到先服务调度算法C语言实现
S_unrise_的博客
05-13 4752
什么是FCFS调度？ FCFS=First-Come First-Served 实现思想：排队买菜 每次从就绪队列中选择一个最先进入的队列的进程，把CPU分给它，直到它运行完成或者因为某些原因阻塞，才放弃CPU。 #include<stdio.h> #include<stdlib.h> typedef struct PCB{ int id;//任务序号 int arrivetime;//任务到达时间 int runtime;//任务需要执行的时间 struct PCB
C语言FCFS算法
12-04
先来先服务算法，使用C语言实现，深入了解进程调度
FCFS算法（c语言）
m0_65536136的博客
05-10 1303
#include<iostream> #include<algorithm> #include<vector> #define num 4 #define col 3 using namespace std; int data[num][col] = {{1,0,120}, {2,50,50}, {3,60,10}, {4,110,20} }...
PSA算法：PID搜索优化算法(PID-based search algorithm, PSA)|经典控制方法：PID控制
最新发布
群智能算法开发
07-20 332
(1)PID控制简介PID控制是一种经典的控制算法，广泛应用于各种工业控制系统中。它通过比例（Proportional）、积分（Integral）、微分（Derivative）三个环节来调节控制量，以达到控制目标。以下是PID控制的基本原理和实现方式：比例§：比例控制是最基本的控制方式，其控制量与偏差成正比。比例系数越大，系统响应越快，但过大的比例系数会导致系统超调和振荡。积分(I)：积分控制用于消除稳态误差，通过累积偏差来调整控制量。
fcfs算法c语言,求高手帮忙写个FCFS的C语言代码，急+++++++++++++++++++++++++…
weixin_42349469的博客
05-21 196
该楼层疑似违规已被系统折叠隐藏此楼查看此楼同问，+!下面的代码是用过的#include //先来先服务//周转arrive---end#define N 22typedef struct job{int startTime;//运行起始时间int endTime;//结束时间int arriveTime;//到达时间int runningTime;//运行时间int troundTime; //...
作业调度FCFS算法C语言
12-04
First-Come, First-Served 按照作业提交或进程变为就绪状态的先后次序，分派CPU；当前作业或进程占用CPU，直到执行完成或阻塞才让出CPU（非抢占方式） 优点：先到的进程先服务，比较利于长作业，利于CPU繁忙的作业 缺点：如果先来的进程需要很长的处理时间，而后来的进程却很重要，这样会有影响，不利于短作业。不利于I/O繁忙的作业。
c语言实现 FCFS和SJF调度算法
04-19
c语言实现 FCFS和SJF调度算法 在vc6.0已经调试通过
操作系统-先来先服务算法FCFS(C语言).doc
11-15
操作系统-先来先服务算法FCFS（C语言） 操作系统中，进程调度算法是核心组件之一，先来先服务（FCFS）算法是最简单的调度算法之一。该算法的基本思想是按照进程的到达时间顺序来执行进程，即最先到达的进程最先被...
磁盘调度算法：在python中模拟磁盘调度算法，例如FCFS，SSTF，SCAN，C-SCAN，LOOK，C-LOOK
02-04
如何使用代码： * run >> python disk_scheduling.py * provide -n=no of i/o requests -hp=initial position of head -requests=n line separated i/o requests 理论： 磁盘调度算法 磁盘调度是由操作系统...
Java模拟操作系统进程调度算法—先来先服务、短作业优先、高响比优先
blogfeifei
10-23 977
首先我们先介绍一下这三个算法，先来先服务是指按照进程到来的时间，谁先来谁执行。短作业优先是指作业服务时间短的先执行。高响比优先是根据公式计算出优先权选出优先权最高的执行，计算高响比优先权的公式：优先权=（等待时间+服务时间）/服务时间。 计算中用到的三个公式： 完成时间=上一个进程的执行时间+服务时间。程序中上一个服务时间是preFinished。 周转时间=完成时间-到达时间。 带权周转...
操作系统先来先服务算法FCFS(C语言).doc
07-13
操作系统先来先服务算法FCFS(C语言).doc
操作系统 作业调度算法FCFS SJF HRN C语言版
10-20
C语言编写的操作系统实验作业：作业调度算法，包括三种算法FCFS,SJF,HRN
调度算法 c语言实现
12-02
调度算法 c语言实现，对很多计算机专业的学生很有用，其中包括FCFS和SJF
操作系统上机资料整合 FIFO,LRU,FCFS,SJF算法都有 C语言 已调试.docx
03-30
。
POA-DPSA算法用于水库优化计算
06-22
POA-DPSA算法用于水库优化计算，采用C++语言
FCFS先来先服务调度算法、PSA优先级调度算法、RR时间片轮转算法（C++实现）
LeopoldZhang2000的博客
02-15 3294
在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。也就是说能运行的进程数远远大于处理及个数。为了使系统中的各进程能有条不紊的运行，必须选择某种调度策略，以选择一进程占用处理机。要求学生设计一模拟单处理机调度的算法，以巩固和加深处理机调度的概念。
psa优先调度算法的c语言,优先级调度算法(PSA)
weixin_34763128的博客
05-24 589
优先级调度算法，即给每个作业一个优先级，优先级越高越紧迫，应该先执行。FCFS算法和SJF算法都可以看做一种特殊的PSA算法。例如，在FCFS算法里，是将算法的到达时间当做优先级，先到达的优先级高。在SJF算法里，将作业的服务时间看做优先级，服务时间短的优先级高。 //main.cpp#include "PSA.h"int main(){std::vector PCBList;//输入作业信息In...
进程调度算法FCFS、SJF(SPF)、SRT、RR原理及代码实现
m0_52744273的博客
03-30 3217
使用c++实现四种常见的进程调度算法
C语言实现FCFS 、SJF 、RR 、PSA调度算法
06-03
以下是C语言实现FCFS、SJF、RR、PSA调度算法的代码示例： ```c #include #include #define MAX_PROCESSES 10 typedef struct { int pid; int arrival_time; int burst_time; int waiting_time; int ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值