操作系统原理与实验——实验十四多道批处理作业调度算法应用二

news2024/11/26 22:50:04

样例

样例一：

1
100
0
5
JOB1 10:06 42分钟 55K
JOB2 10:20 30分钟 40K 
JOB3 10:30 24分钟 35K 
JOB4 10:36 15分钟 25K 
JOB5 10:42 12分钟 20K 
2
100
0
5
JOB1 10:06 42分钟 55K
JOB2 10:20 30分钟 40K 
JOB3 10:30 24分钟 35K 
JOB4 10:36 15分钟 25K 
JOB5 10:42 12分钟 20K
3
100
0
5
JOB1 10:06 42分钟 55K
JOB2 10:20 30分钟 40K 
JOB3 10:30 24分钟 35K 
JOB4 10:36 15分钟 25K 
JOB5 10:42 12分钟 20K
0

样例二：
1
100
0
5
JOB3 10:30 24分钟 35K 
JOB1 10:06 42分钟 55K
JOB2 10:20 30分钟 40K 
JOB5 10:42 12分钟 20K 
JOB4 10:36 15分钟 25K 
2
100
0
5
JOB1 8:00 40分钟 35K
JOB2 8:10 30分钟 70K 
JOB3 8:15 20分钟 50K 
JOB4 8:35 10分钟 25K 
JOB5 8:40 5分钟 20K
1
100
0
5
11 8:00 40分钟 35K
21 8:10 30分钟 70K 
31 8:15 20分钟 50K 
41 8:35 10分钟 25K 
51 8:40 5分钟 20K

关键代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct  data{
    int hour;//当前小时
    int min;//当前分钟
}time;
struct node{
    char name[20];//进程名
    time arrive;//到达就绪队列时间
    int zx;//执行时间(预期时间)
    int size;
    time zhuangru; 
    time start;//开始执行时间(进程调度)
    time finish;//执行完成时间
    int zz;//周转时间=完成时间-到达就绪队列时间
    float zzxs;//带权周转时间系数=周转时间/执行时间
    struct node* next;
};
//内存结构体

typedef struct memory_node{
    int size; //内存大小
    int address; //内存始址
} memoryNode;
memoryNode memory;

//函数名：in参数：无
node* in(){
//函数功能:输入访问序列信息
	int n;
	node *q,*head;
	head = NULL; 
	printf("请输入内存大小：");
	scanf("%d",&memory.size);
	printf("请输入起始地址大小为：");
	scanf("%d",&memory.address);
	printf("请输入进程数量：");
	scanf("%d",&n);
	printf("请输入进程的参数：\n"); 
	for(int i=0;i<n;i++)
	{
		node *p = (node *)malloc(sizeof(node));
		p->next = NULL;
		scanf("%s %d:%d %d分钟 %dK",&p->name,&p->arrive.hour,&p->arrive.min,&p->zx,&p->size);
		if(head == NULL) //尾插法 
		{
			head = p;
			q = p;
		} 
		else
		{
			q->next = p;
			q = p;
		}
	}
	
	return head;
}

void output(node *p) {
    //函数功能：按进程执行顺序分别输出每个进程全部结果信息和系统平均时间
   int sum=0,count=0; 
   float sum1=0; 
   printf("\n模拟进程FCFS调度过程输出结果:\n作业名   到达时间   执行时间（分钟）    装入时间   开始时间   完成时间  周转时间（分钟）  带权周转系数\n");
   while(p!=NULL)
   {
    	printf("%5s ",p->name);
    	printf("%5d:%02d ",p->arrive.hour,p->arrive.min);
    	printf("%8d(分钟) ",p->zx);
    	printf("%14d:%02d ",p->zhuangru.hour,p->zhuangru.min);
    	printf("%6d:%02d ",p->start.hour,p->start.min);
    	printf("%7d:%02d ",p->finish.hour,p->finish.min);
    	printf("%7d ",p->zz);
    	printf("%20.2f\n",p->zzxs);
    	sum=sum+p->zz;
    	sum1=sum1+p->zzxs;
    	count++;
    	p=p->next;
   }
   printf("系统平均周转时间为：%.2f\n",sum*1.0/count);
   printf("系统平均带权周转系数为：%.2f\n\n",sum1/count);
}
//函数名：FCFS参数：无
void FCFS(){
//函数功能:调用来先服务调度算法(FCFS) 
	printf("\n***********FCFS多道批处理作业调度***********\n");
	node *head = in();
	node *h,*q;
	h = NULL;
	q = head;
	while(q!=NULL)//对进程按到达时间先后排序 
	{
		node *p = (node *)malloc(sizeof(node));
		*p = *q;
		p->next = NULL; 
		if(h == NULL)
		{
			h = p;
		}
		else
		{
			node *a,*apre;
			a = h;
			while(a!=NULL)
			{
				if(p->arrive.hour*60+p->arrive.min<a->arrive.hour*60+a->arrive.min)
				break;
				apre = a;
				a = a->next;
			}
			if(a == h)
			{
				p->next = h;
				h = p;
			}
			else
			{
				p->next = a;
				apre->next = p;
			}
		}
		q = q->next;
	} 
	//开始FCFS算法 
	time now;
	node *yx,*dd,*ppre,*fdd,*outcome,*foutcome,*p;//yx:运行队列 dd:等待队列 ppre:p的前驱 fdd:等待队列的尾结点 outcome:结果队列 foutcome:结果队列的尾结点 p:用于遍历h 
	int space; 
	now.hour = 0;
	now.min = 0;
	yx = NULL;
	dd = NULL;
	outcome = NULL;
	space = memory.size;
	while(h!=NULL)
	{
		//每一次大循环都找在自己执行完的时间内并且符合条件的 摘下来 
		//大循环每次末尾都回收第一个 
		p = h;
		while(p!=NULL)
		{
			if(yx == NULL)//操作运行队列 两种情况：一是第一次运行 二是等待队列中没有进程 
			{
				h = h->next;
				p->next = NULL;
				yx = p;
				p = h;
				if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min)//（进程到达时间 > 当前时间 ）——>更新当前时间 
				{
					now.hour = yx->arrive.hour;
					now.min = yx->arrive.min;
				}
				yx->zhuangru.hour = now.hour;
				yx->zhuangru.min = now.min;
				yx->start.hour = now.hour;
				yx->start.min = now.min;
				space -= yx->size;
			} 
			//在有进程运行的同时，寻找满足条件的进程 
			//条件是：（1）在进程运行完成之前到达 （2）并且有空间 
			if(p->arrive.hour*60+p->arrive.min<=yx->start.hour*60+yx->start.min+yx->zx&&space-p->size>=0)
			{
				//修改装入时间 ，但还不能修改当前时间 
				if(now.hour*60+now.min>p->arrive.hour*60+p->arrive.min)
				{
					p->zhuangru.hour = now.hour;
					p->zhuangru.min = now.min;
				}
				else
				{
					p->zhuangru.hour = p->arrive.hour;
					p->zhuangru.min = p->arrive.min;
				}
				space -= p->size;
				//把要装入主存的进程从队列中取下接到等待队列中 
				if(p == h)
				{
					h = h->next;
					p->next =NULL;
					if(dd == NULL)
					{
						dd = p;
						fdd = dd;
					}
					else
					{
						fdd->next = p;
						fdd = p;
					}
					p = h; 
				}
				else
				{
					ppre->next = p->next;
					p->next = NULL;
					if(dd == NULL)
					{
						dd = p;
						fdd = dd;
					}
					else
					{
						fdd->next = p;
						fdd = p;
					}
					p = ppre->next;
				} 
			}
			else//不满足条件继续遍历 h 
			{ 
				ppre = p;
				p = p->next;
			}
		}
		//回收资源(即开始运行进程)
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;//计算周转时间 
		k->zzxs = k->zz*1.0/k->zx;//计算周转系数 
		space += k->size;//回收空间 
		//将运行完的进程记录在outcome中，以便后续打印 
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		//从等待队列中取进程到运行队列中，并更新当前时间 
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}
	}
	//等待队列和运行队列可能不为空 
	//将等待队列中的结点放入到运行队列中 
	while(1)
	{
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;
		k->zzxs = k->zz*1.0/k->zx;
		space += k->size;
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}
		if(yx == NULL&&dd == NULL)
		break;
	}
	output(outcome);
}
//函数名：SPF参数：无
void SPF(){
//函数功能:调用最短作业优先算法(SPF) 
	printf("\n***********SPF多道批处理作业调度***********\n");
	node *head = in();
	node *h,*q;
	h = NULL;
	q = head;
	while(q!=NULL)//对进程按到达时间先后排序 
	{
		node *p = (node *)malloc(sizeof(node));
		*p = *q;
		p->next = NULL; 
		if(h == NULL)
		{
			h = p;
		}
		else
		{
			node *a,*apre;
			a = h;
			while(a!=NULL)
			{
				if(p->arrive.hour*60+p->arrive.min<a->arrive.hour*60+a->arrive.min)
				break;
				apre = a;
				a = a->next;
			}
			if(a == h)
			{
				p->next = h;
				h = p;
			}
			else
			{
				p->next = a;
				apre->next = p;
			}
		}
		q = q->next;
	} 
	//开始SPF算法 
	time now;
	node *yx,*dd,*ppre,*fdd,*outcome,*foutcome,*p,*pp;
	int space; 
	now.hour = 0;
	now.min = 0;
	yx = NULL;
	dd = NULL;
	outcome = NULL;
	space = memory.size;
	while(h!=NULL)
	{
		//每一次大循环都找在自己执行完的时间内并且符合条件的 摘下来 
		//大循环每次末尾都回收第一个 
		pp = h;
		if(yx == NULL)//操作运行队列  两种情况：一是第一次运行 二是等待队列中没有进程 
		{
			h = h->next;
			pp->next = NULL;
			yx = pp;
			pp = h;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min)//（进程到达时间 > 当前时间 ）——>更新当前时间
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->zhuangru.hour = now.hour;
			yx->zhuangru.min = now.min;
			yx->start.hour = now.hour;
			yx->start.min = now.min;
			space -= yx->size;
		} 
		//寻找满足条件的进程 
		//对队列按运行时间的大小排序（短进程在前） ，得到队列:duilie 
		node *w,*duilie,*prew,*ww;//w:遍历h duilie:排序后的队列 prew:记录ww的前驱 ww:遍历duilie(找合适的位置插入结点) 
		w = h; 
		duilie = NULL;
		while(w!=NULL)
		{
			node *o = (node *)malloc(sizeof(node));
			*o = *w;
			o->next = NULL;
			if(duilie==NULL)
			{
				duilie = o;
			}
			else
			{
				ww = duilie;
				while(ww!=NULL)
				{
					if(o->zx<ww->zx)
					break;
					prew = ww;
					ww = ww->next;
				}
				if(ww==duilie)
				{
					o->next = duilie;
					duilie = o;
				}
				else
				{
					o->next = ww;
					prew->next = o;
				}
			}
			w = w->next;
		}
		//在排序后的队列duilie中寻找满足条件的进程 
		p = duilie;
		while(p!=NULL)
		{
			//在有进程运行的同时，寻找满足条件的进程 
			//条件是：（1）在进程运行完成之前到达 （2）并且有空间 
			if(p->arrive.hour*60+p->arrive.min<=yx->start.hour*60+yx->start.min+yx->zx&&space-p->size>=0)
			{
				space -= p->size;
				//删除h上的结点 
				node *check,*precheck;//摘下 
				check = h;
				while(check!=NULL)
				{
					if(strcmp(p->name,check->name)==0)
					break;
					precheck = check;
					check = check->next;
				}
				if(check==h)
				{
					h = h->next;
				}
				else
				{
					precheck->next = check->next;
				}
				check->next = NULL;
				if(dd == NULL)//把摘下的进程放入等待队列 
				{
					dd = check;
					fdd = dd;
				}
				else
				{
					fdd->next = check;
					fdd = check;
				}
				//修改装入时间 
				if(now.hour*60+now.min>check->arrive.hour*60+check->arrive.min)
				{
					check->zhuangru.hour = now.hour;
					check->zhuangru.min = now.min;
				}
				else
				{
					check->zhuangru.hour = check->arrive.hour;
					check->zhuangru.min = check->arrive.min;
				}
				
			}
			p = p->next;
		}  
		//回收资源(即开始运行进程)
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;//计算周转时间 
		k->zzxs = k->zz*1.0/k->zx;//计算周转系数 
		space += k->size;//回收空间 
		//将运行完的进程记录在outcome中，以便后续打印 
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		//从等待队列中取进程到运行队列中，并更新当前时间 
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}
	} 
	//等待队列和运行队列可能不为空 
	//将等待队列中的结点放入到运行队列中
	while(yx!=NULL)
	{
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;
		k->zzxs = k->zz*1.0/k->zx;
		space += k->size;
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}
	}
	output(outcome);
}
//函数名：HRRF参数：无
void HRRF(){
//函数功能:调用响应比最高者优先算法(HRRF)
	printf("\n***********HRRF多道批处理作业调度***********\n");
	node *head = in();
	node *h,*q;
	h = NULL;
	q = head;
	while(q!=NULL)//对进程按到达时间先后排序
	{
		node *p = (node *)malloc(sizeof(node));
		*p = *q;
		p->next = NULL; 
		if(h == NULL)
		{
			h = p;
		}
		else
		{
			node *a,*apre;
			a = h;
			while(a!=NULL)
			{
				if(p->arrive.hour*60+p->arrive.min<a->arrive.hour*60+a->arrive.min)
				break;
				apre = a;
				a = a->next;
			}
			if(a == h)
			{
				p->next = h;
				h = p;
			}
			else
			{
				p->next = a;
				apre->next = p;
			}
		}
		q = q->next;
	}  
	//开始HRRF算法 
	time now;
	node *yx,*dd,*ppre,*fdd,*outcome,*foutcome,*p,*pp;
	int space,nonow; 
	now.hour = 0;
	now.min = 0;
	yx = NULL;
	dd = NULL;
	outcome = NULL;
	space = memory.size;
	while(h!=NULL)
	{
		//每一次大循环都找在自己执行完的时间内并且符合条件的 摘下来 
		//大循环每次末尾都回收第一个 
		pp = h;
		if(yx == NULL)//操作运行队列 两种情况：一是第一次运行 二是等待队列中没有进程 
		{
			h = h->next;
			pp->next = NULL;
			yx = pp;
			pp = h;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min)//（进程到达时间 > 当前时间 ）——>更新当前时间
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->zhuangru.hour = now.hour;
			yx->zhuangru.min = now.min;
			yx->start.hour = now.hour;
			yx->start.min = now.min;
			nonow = (yx->start.hour+(yx->start.min+yx->zx)/60)*60+(yx->start.min+yx->zx)%60;//记下运行进程的结束时间，用于计算响应比 
			space -= yx->size;
		} 
		//寻找满足条件的进程 
		//对队列按响应比排序（响应比高的在前面） ，得到队列:duilie 
		node *w,*duilie,*prew,*ww;//w:遍历h duilie:排序后的队列 prew:记录ww的前驱 ww:遍历duilie(找合适的位置插入结点) 
		w = h; 
		duilie = NULL;
		while(w!=NULL)
		{
			node *o = (node *)malloc(sizeof(node));
			*o = *w;
			o->next = NULL;
			if(duilie==NULL)
			{
				duilie = o;
			}
			else
			{
				ww = duilie;
				while(ww!=NULL)
				{
					if((nonow-o->arrive.hour*60-o->arrive.min)>0&&(nonow-o->arrive.hour*60-o->arrive.min+o->zx)*1.0/o->zx>(nonow-ww->arrive.hour*60-ww->arrive.min+ww->zx)*1.0/ww->zx)
					break;
					prew = ww;
					ww = ww->next;
				}
				if(ww==duilie)
				{
					o->next = duilie;
					duilie = o;
				}
				else
				{
					o->next = ww;
					prew->next = o;
				}
			}
			w = w->next;
		}
		//在排序后的队列duilie中寻找满足条件的进程 		
		p = duilie;
		while(p!=NULL)
		{
			//在有进程运行的同时，寻找满足条件的进程 
			//条件是：（1）在进程运行完成之前到达 （2）并且有空间
			if(p->arrive.hour*60+p->arrive.min<=yx->start.hour*60+yx->start.min+yx->zx&&space-p->size>=0)
			{
				space -= p->size;
				//删除h上的结点 
				node *check,*precheck;//摘下 
				check = h;
				while(check!=NULL)
				{
					if(strcmp(p->name,check->name)==0)
					break;
					precheck = check;
					check = check->next;
				}
				if(check==h)
				{
					h = h->next;
				}
				else
				{
					precheck->next = check->next;
				}
				check->next = NULL;
				if(dd == NULL)//把摘下的进程放入等待队列
				{
					dd = check;
					fdd = dd;
				}
				else
				{
					fdd->next = check;
					fdd = check;
				}
				//修改装入时间 
				if(now.hour*60+now.min>check->arrive.hour*60+check->arrive.min)
				{
					check->zhuangru.hour = now.hour;
					check->zhuangru.min = now.min;
				}
				else
				{
					check->zhuangru.hour = check->arrive.hour;
					check->zhuangru.min = check->arrive.min;
				}
			}
			p = p->next;
		}
		//回收资源(即开始运行进程)
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;//计算周转时间 
		k->zzxs = k->zz*1.0/k->zx;//计算周转系数 
		space += k->size;//回收空间
		//将运行完的进程记录在outcome中，以便后续打印  
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		//从等待队列中取进程到运行队列中，并更新当前时间 
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}
	} 
	//等待队列和运行队列可能不为空 
	//将等待队列中的结点放入到运行队列中
	while(yx!=NULL)
	{
		node *k;
		k = yx;
		yx = yx->next;
		k->start.hour = now.hour;
		k->start.min = now.min;
		now.hour = k->start.hour+(k->start.min+k->zx)/60;
		now.min = (k->start.min+k->zx)%60;
		k->finish.hour = now.hour;
		k->finish.min = now.min;
		k->zz = k->finish.hour*60+k->finish.min-k->arrive.hour*60-k->arrive.min;
		k->zzxs = k->zz*1.0/k->zx;
		space += k->size;
		if(outcome == NULL)
		{
			outcome = k;
			foutcome = outcome;
		}
		else
		{
			foutcome->next = k;
			foutcome = k;
		}
		if(yx == NULL&&dd!=NULL)
		{
			node *y;
			y = dd;
			dd = dd->next;
			y->next = NULL;
			yx = y;
			if(yx->arrive.hour*60+yx->arrive.min>now.hour*60+now.min) //更新now 
			{
				now.hour = yx->arrive.hour;
				now.min = yx->arrive.min;
			}
			yx->start.hour = now.hour;
			yx->start.min = now.min;
		}	
	}
	output(outcome);
}

//函数名：Out参数：无
void Out(){
//函数功能:输出选项菜单
	printf("***************多道批处理作业调度***************\n");
	printf("  *        1.先来先服务调度算法(FCFS)          *\n");
	printf("  *        2.最短作业优先算法(SPF)             *\n");
	printf("  *        3.响应比最高者优先算法(HRRF)        *\n");
	printf("  *        0.退出                              *\n");
	printf("           请输入选项[ ]\b\b");
}
int main()
{
    while (1)
    {
        Out();//给出选项
        int c;
        scanf("%d", &c);
        switch (c){//选择算法
        case 1:FCFS();
            break;
        case 2:SPF();
            break;
        case 3:HRRF();
            break;
        default:printf("\n调度结束！");
            exit(1);
        }
    }
    return 0;
}

实验结果

实验总结

①新建链表的插入，尾插法是最容易的；

②删除结点的时候没有考虑是头结点；

③在修改结点的属性时，没有实际修改，因为修改后的结点仅仅用来查找；

④没有注意到实际情况，进程还未到达是就被我装入主存中了；

⑤对链表的操作有时会去找空指针的属性，导致程序意外中断；

⑥当从等待队列中取进程时，要判断所取的进程的到达时间是否大于当前时间，如果是则更新当前时间。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1669077.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

开发一款相亲交友小程序

开发一款相亲交友小程序

uni-app框架&#xff1a;使用Vue.js开发跨平台应用的前端框架&#xff0c;编写一套代码&#xff0c;可编译到Android、小程序等平台。 框架支持:springboot/Ssm/thinkphp/django/flask/express均支持 前端开发:vue.js 可选语言&#xff1a;pythonjavanode.jsphp均支持 运行软件…
阅读更多...
探索共享内存：解锁并发编程的潜力

探索共享内存：解锁并发编程的潜力

文章目录 序言shm 原理对shm的理解通过代码认识shm调用shmget方法实现 序言 system V版本 指定的一种规则(俗话说一流公司定规则,二流公司重服务,三流公司重技术).这个规则虽然有很多种(消息队列,共享内存等只是比较出名的几个).但是在内核的相关技术解决上是类似的,因为都是基…
阅读更多...
NIUKE SQL：进阶挑战 (下)

NIUKE SQL：进阶挑战 (下)

05 窗口函数 专用窗口函数 SQL136 每类试卷得分前3名 找到每类试卷得分的前3名&#xff0c;如果两人最大分数相同&#xff0c;选择最小分数大者&#xff0c;如果还相同&#xff0c;选择uid大者 SELECT tag,uid,ranking FROM(SELECTtag,ER.uid,ROW_NUMBER() OVER (PARTITION …
阅读更多...
jdk8的新特征

jdk8的新特征

1&#xff1a; jdk8中新增的方法 在jdk8中对接口进行了增强&#xff0c;在jdk8之前 interface 接口名{ 静态常量&#xff1a; 抽象方法&#xff1a; } 在jdk8之后 interface 接口名{ 静态常量&#xff1a; 抽象方法&#xff1a; 默认方法&#xff1a; 静态方法&#xff1a; } 2…
阅读更多...
【IMX6ULL项目】IMX6ULL下Linux实现产测工具框架

【IMX6ULL项目】IMX6ULL下Linux实现产测工具框架

电子产品量产测试与烧写工具。这是一套软件&#xff0c;用在我们的实际生产中&#xff0c; 有如下特点&#xff1a; 1.简单易用&#xff1a; 把这套软件烧写在 SD 卡上&#xff0c;插到 IMX6ULL 板子里并启动&#xff0c;它就会自动测试各个模块、烧写 EMMC 系统。 工人只要按…
阅读更多...
【算法】dfs

【算法】dfs

快乐的流畅&#xff1a;个人主页 个人专栏&#xff1a;《算法神殿》《数据结构世界》《进击的C》 远方有一堆篝火&#xff0c;在为久候之人燃烧&#xff01; 文章目录 引言一、全排列1. 决策树2. 设计代码1. 全局变量2. dfs函数3. 细节问题 二、子集解法一1. 决策树2. 设计代码…
阅读更多...
Spring Boot：让微服务开发像搭积木一样简单！

Spring Boot：让微服务开发像搭积木一样简单！

带你一探 Spring Boot 的自动配置和 Starter POMs 的神奇之处&#xff0c;展示如何通过几个简单的步骤就能让你的微服务应用在云端翱翔&#xff01; 文章目录 1. 引言1.1 简述Spring框架的起源与重要性1.2 阐述文章目的&#xff1a;深入解析Spring核心功能与应用实践2. 背景介绍…
阅读更多...
C语言 | Leetcode C语言题解之第85题最大矩形

C语言 | Leetcode C语言题解之第85题最大矩形

题目&#xff1a; 题解&#xff1a; int maximalRectangle(char** matrix, int matrixSize, int* matrixColSize) {int m matrixSize;if (m 0) {return 0;}int n matrixColSize[0];int left[m][n];memset(left, 0, sizeof(left));for (int i 0; i < m; i) {for (int j …
阅读更多...
251 基于matlab的动态粒子群算法

251 基于matlab的动态粒子群算法

基于matlab的动态粒子群算法。普通粒子群算法无法感知外界环境的变化&#xff0c;在外界环境发生改变时无法实时进行响应&#xff0c;因而缺乏动态环境寻优能力。在普通粒子群算法基本上通过增加敏感粒子得到一种动态粒子群算法&#xff0c;该算法通过实时计算敏感粒子的适应度…
阅读更多...
Redis集群安装

Redis集群安装

将Redis安装包分别上传到3个文件夹&#xff0c;并解压缩 #编译并指定安装目录 cd /root/usr/local/redis-cluster/redis-7001/redis-6.2.6/ make make PREFIX/root/usr/local/redis-cluster/redis-7001 install # cd /root/usr/local/redis-cluster/redis-7002/redis-6.2.6/ m…
阅读更多...
iZotope RX 11 for Mac 激活版：让您的音频焕发生机！

iZotope RX 11 for Mac 激活版：让您的音频焕发生机！

在追求音频完美的道路上&#xff0c;iZotope RX 11 for Mac是您的得力助手。它凭借先进的音频修复技术和丰富的音频增强工具&#xff0c;让您的音频作品焕发出前所未有的生机与活力。无论您是专业的音频工程师&#xff0c;还是业余的音乐爱好者&#xff0c;都能在这款工具中找到…
阅读更多...
栈的讲解

栈的讲解

栈的概念及结构 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除操作的一端称为栈顶&#xff0c;另一端称为栈底&#xff08;因为先进后出&#xff09;。栈中的数据元素遵守后进先出LIFO&#xff08;Last In Firs…
阅读更多...
【Threejs进阶教程-算法篇】1.常用坐标系介绍与2d/3d随机点位算法

【Threejs进阶教程-算法篇】1.常用坐标系介绍与2d/3d随机点位算法

2d/3d随机算法 学习ThreeJS的捷径坐标系简介平面直角坐标系和极坐标系空间直角坐标系圆柱坐标系球坐标系球坐标系与直角坐标系的转换 基于坐标系系统的随机点位算法平面直角坐标系随机平面直角坐标系随机的变形 空间直角坐标系随机二维极坐标系随机圆柱坐标系随机基于Cylinderc…
阅读更多...
Python 整数类型（int）详解：无限范围与多种进制

Python 整数类型（int）详解：无限范围与多种进制

引言 在编程中&#xff0c;整数是最基本的数据类型之一。不同编程语言对整数的处理方式各不相同&#xff0c;这往往影响到程序的性能和开发者的选择。本文将深入探讨 Python 中的整数类型&#xff08;int&#xff09;&#xff0c;其独特的处理方式&#xff0c;以及它在日常编程…
阅读更多...
Lambda表达式 怎么debug调试

Lambda表达式 怎么debug调试

前言 Lambda 表达式是 JDK8 的一个重要新特性&#xff0c;可以取代大部分的匿名内部类&#xff0c;写出更优雅的 Java 代码&#xff0c;尤其在集合的遍历和其他集合操作中&#xff0c;可以极大地优化代码结构。JDK 也提供了大量的内置函数式接口供我们使用&#xff0c;使得 La…
阅读更多...
【Chrome实用命令笔记】

【Chrome实用命令笔记】

文章目录 Chrome实用命令笔记1、chrome基本介绍2. 打开开发者工具&#xff08;DevTools&#xff09;方法一&#xff1a;快捷键方法二&#xff1a;右键菜单方法三&#xff1a;浏览器设置 2. 开发者工具面板Elements面板Console面板Sources面板Network面板Performance面板Memory面…
阅读更多...
C++ 数据结构算法 学习笔记(25) - 图及其企业级应用

C++ 数据结构算法 学习笔记(25) - 图及其企业级应用

C 数据结构算法 学习笔记(25) - 图及其企业级应用 图的故事导入 故事情节 Jack 自从买车后&#xff0c;交通出行方便了&#xff0c;心自然就野了&#xff01;身边的各种朋友自然就多了起来&#xff01; 有一天晚上&#xff0c;一个年轻漂亮的女同事生日&#xff0c;Jack 受邀…
阅读更多...
python 自定义包的实现

python 自定义包的实现

1. 代码目录 创建自定义包的时候&#xff0c;原理是当 python 检测到一个目录下存在 __init__.py 文件时&#xff0c;python 就会把它当成一个模块(module)。 下面这个例子是网上整理的代码&#xff0c;但是有些小改动&#xff0c;可以直接拿来就用。 看代码结构&#xff1a;…
阅读更多...
springboot+vue+mybatis社交网络平台+PPT+论文+讲解+售后

springboot+vue+mybatis社交网络平台+PPT+论文+讲解+售后

近些年来&#xff0c;随着科技的飞速发展&#xff0c;互联网的普及逐渐延伸到各行各业中&#xff0c;给人们生活带来了十分的便利&#xff0c;社交网络平台利用计算机网络实现信息化管理&#xff0c;使整个社交网络管理的发展和服务水平有显著提升。 本文拟采用Eclipse开发工具…
阅读更多...
免费证件照一键换底色

免费证件照一键换底色

最近星期天在家搞了一个小工具&#xff0c;在这里分享下! 废话不多说看看效果&#xff1a; 效果还不错&#xff0c;需要的可以联系我!!!!!!!!! 别的网上可都是一次五块钱这种。太贵了。。&#xff01;&#xff01;
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023