湖北师范大学操作系统实验(java版)

📑前言

本文主要是【操作系统】——操作系统实验题的文章,如果有什么需要改进的地方还请大佬指出⛺️

🎬作者简介:大家好,我是听风与他🥇
☁️博客首页:CSDN主页听风与他
🌄每日一句:狠狠沉淀,顶峰相见

进程调度1—静态非剥夺式优先级调度计算平均作业周转时间

问题描述:要求输入3个进程的信息,假设这些进程均是在0时刻同时到达,若进程调度采用非剥夺式静态优先级(优先数数值大的表示优先级比较高;如果遇到优先级一样,按照输入顺序执行。),计算并输出平均作业周转时间。

输入格式:程序要求输入3行,以回车符号作为分隔,每行有3个数据,以空格作为分隔。首先输入一个字符串(长度小于等于10),为进程名,第2个数据类型为整型,表示进程的优先数,第3个数据类型为整型,表示进程的运行时间。

输出格式:输出结果为一个浮点数,保留到小数点后一位,为系统的平均作业周转时间。

样例输入1:
P1 1 1
P2 2 2
P3 3 3
样例输出1:
4.7

样例输入2:
P1 10 10
P2 100 100
P3 100 100
样例输出2:
170.0

参考代码


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class Main {
/*
P1 1 1
P2 2 2
P3 3 3

4.7

P1 10 10
P2 100 100
P3 100 100

170.0

 */
	public static class node implements Comparable<node>{
		String job;//作业名
		int prior;//优先级
		int time;//运行时间
		public node(String job,int prior,int time)
		{
			this.job=job;
			this.prior=prior;
			this.time=time;
		}
		//实现按优先级从小到大排序
		@Override
		public int compareTo(node o) {
			// TODO Auto-generated method stub
			return this.prior-o.prior;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
       Scanner sc=new Scanner(System.in);
       List<node> list=new ArrayList<>();
       for(int i=0;i<3;i++)
       {
    	   String job=sc.next();
    	   int prior=sc.nextInt();
    	   int time=sc.nextInt();
    	   list.add(new node(job,prior,time));
       }
       Collections.sort(list);
       //最后的总周转时间累加
       float ans=(float)(list.get(0).time+list.get(1).time*2+list.get(2).time*3)/3;
       System.out.printf("%.1f",ans);
	}

}

进程调度2–最高响应比优先计算每个作业的周转时间

问题描述:要求输入3个进程的信息,按照最高响应比优先的调度算法计算并输出每个进程的周转时间。(若两个进程的响应比相同,则优先选择先进入的进程。若两个进程的响应比相同,而且进入时刻也相同,则按照输入的顺序执行,如:P4和P6的响应比相同且进入时刻也相同,如P4先输入则选择P4先执行)

输入格式:程序要求输入3行,以回车符号作为分隔,每行有3个数据,以空格作为分隔。首先输入一个字符串(长度小于等于10),为进程名,第2个数据类型为整型,表示进程的进入时刻,第3个数据类型为整型,表示进程的运行时间。

输出格式:输出三个整数之间,整数之间用空格作为分隔,为每个进程的周转时间。

样例输入1:
P1 1 1
P2 2 2
P3 3 3
样例输出1:
1 2 4

样例输入2:
P1 1 4
P2 2 8
P3 3 1
样例输出2:
4 12 3

参考代码


import java.util.*;

public class Main {
/*
P1 1 1
P2 2 2
P3 3 3
样例输出1:
1 2 4

样例输入2:
P1 1 4
P2 2 8
P3 3 1 
样例输出2:
4 12 3

 */
	public static class node implements Comparable<node>{
		String job;//作业名
		int enter;//进入时间
		int time;//运行时间
		int t;//周转时间
		public node(String job,int enter,int time,int t)
		{
			this.job=job;
			this.enter=enter;
			this.time=time;
			this.t=t;
		}
		//按进入时间从小到大排序
		@Override
		public int compareTo(node o) {
			// TODO Auto-generated method stub
			return this.enter-o.enter;
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
     Scanner sc=new Scanner(System.in);
     List<node> list=new ArrayList<>();
     String a[]=new String[3];
     for(int i=0;i<3;i++)
     {
    	 String job=sc.next();
    	 a[i]=job;//将初始的作业名保存,防止排序后丢失
    	 int enter=sc.nextInt();
    	 int time=sc.nextInt();
    	 //初始时周转时间都为0
    	 list.add(new node(job,enter,time,0));
     }
     Collections.sort(list);
     float sum=0;
     int t1=0,t2=0,t3=0;
     t1=list.get(0).time;
     list.get(0).t=t1;
     //最先进入的作业可直接计算周转时间
     sum+=list.get(0).enter+list.get(0).time;
    	 float a1=(sum-list.get(1).enter)/list.get(1).time;
    	 float a2=(sum-list.get(2).enter)/list.get(2).time;
    	 //作业2和3都在作业1结束之前进入
    	 if(list.get(1).enter<=sum&&list.get(2).enter<=sum)
    	 {
    		 if(a1>=a2)
    		 {
    		 sum+=list.get(1).time;
    		 t2=(int)sum-list.get(1).enter;
    		 sum+=list.get(2).time;
    		 t3=(int)sum-list.get(2).enter;
    		 list.get(1).t=t2;
    		 list.get(2).t=t3;
    	     }else {
    		 sum+=list.get(2).time;
    		 t2=(int)sum-list.get(2).enter;
    		 sum+=list.get(1).time;
    		 t3=(int)sum-list.get(1).enter;
    		 list.get(2).t=t2;
    		 list.get(1).t=t3;
    	 }
    		 //作业2在作业1结束之前进入,作业3在作业1结束之后进入
    	 }else if(list.get(1).enter<=sum&&list.get(2).enter>sum)
    	 {
             list.get(1).t=(int)sum+list.get(1).time-list.get(1).enter;
             if(list.get(2).enter>=sum+list.get(1).time)
             {
            	 list.get(2).t=list.get(2).time;
             }else {
            	 list.get(2).t=(int)sum+list.get(1).time+list.get(2).time-list.get(2).enter;
             }
             //作业都在作业1结束之后进入
    	 }else {
    		 list.get(1).t=list.get(1).time;
    		 if(list.get(2).enter>=list.get(1).enter+list.get(1).time)
    		 {
    			 list.get(2).t=list.get(2).time;
    		 }else {
    			 list.get(2).t=list.get(1).enter+list.get(1).time+list.get(2).time-list.get(2).enter;
    		 }
    	 }
    	 for(int i=0;i<3;i++)
    	 {
    		 for(int j=0;j<3;j++)
    		 {
    			 if(a[i]==list.get(j).job)
    			 {
    				 System.out.print(list.get(j).t+" ");
    			 }
    		 }
    	 }
	}

}

并发进程的分类—利用BERSTEIN条件判断语句的无关性与交互性

问题描述:要求输入两条赋值语句(赋值号为:=),且语句中仅仅有加减乘除运算,利用BERSTEIN条件判断语句的无关性与交互性。

输入格式:程序要求输入两行,以回车符号作为分隔,每一行即为一条语句。

输出格式:输出一个字符串。若为交互性语句则输出为”false”(不含双引号,所有字母皆为小写);若为无关性语句则输出”true”(不含双引号,所有字母皆为小写)。

样例输入1:
x:=m+n;
y:=2*k;
样例输出1:
true

样例输入2:
x:=m+n;
m:=2*k;
样例输出2:
false

参考代码


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{
/*
样例输入1:
x:=m+n;
y:=2*k;
样例输出1:
true

样例输入2:
x:=m+n;
m:=2*k;
样例输出2:
false

*/

/*
为例:
x:=m+n;
y:=2*k;
将m及n取出放在容器r1中,将k取出放在容器r2中
x和y可直接截取进行比较,通过容器的contains()进行比较
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       Scanner sc=new Scanner(System.in);
       String s1=sc.next();
       String s2=sc.next();
       String w1=s1.substring(0,1);
       int l1=0,l2=0;
       String w2=s2.substring(0,1);
       List<String> r1=new ArrayList<String>();
       List<String> r2=new ArrayList<String>();
       //取出与x相关的变量
       for(int i=2;i<s1.length()-1;i++)
       {
    	   if(s1.charAt(i)!='+'&&s1.charAt(i)!='-'&&s1.charAt(i)!='*'&&s1.charAt(i)!='/')
    	   {
                 r1.add(String.valueOf(s1.charAt(i)));
    	   }
       }
       //取出与y相关的变量
       for(int i=2;i<s2.length()-1;i++)
       {
    	   if(s2.charAt(i)!='+'&&s2.charAt(i)!='-'&&s2.charAt(i)!='*'&&s2.charAt(i)!='/')
    	   {
                 r2.add(String.valueOf(s2.charAt(i)));
    	   }
       }
       //进行无关性比较
       if(!w1.equals(w2)&&!r1.contains(w2)&&!r2.contains(w1))
    	{
    	   System.out.print("true");
    	}else {
    		System.out.println("false");
    	}
	}

}

死锁—利用银行家算法判断资源是否可以申请成功

问题描述:假设系统中有A、B、C三类资源,且有五个并发进程,要求输入当前系统可用资源量Available,以及每个进程运行所需的资源总量Claim、已经分配得到的资源量Allocation和进程的资源申请。利用银行家算法判断进程的资源申请能否得到系统的满足。

输入格式:程序要求输入七行,以回车符号作为分隔。第一行是三个整数,整数之间以空格作为分隔,表示当前系统可用的A、B、C三类资源量Available。下面的五行分别表示每个进程运行所需的资源总量Claim和已经分配得到的资源量Allocation;每行有7个数据,以空格作为分隔。首先输入一个字符串(长度小于等于10),为进程名;第2、3、4个数据类型为整型,表示相应进程运行所需A、B、C三种资源总量Claim;第5、6、7个数据类型为整型,表示相应进程已经分配得到的A、B、C三种资源量Allocation。第七行有4个数据,以空格作为分隔。首先输入一个字符串(长度小于等于10),为申请资源的进程名;第2、3、4个数据类型为整型,表示所申请A、B、C三种资源的量。

输出格式:输出一个字符串。若系统不能满足资源申请则输出为”false”(不含双引号,所有字母皆为小写);若系统可以满足资源申请则输出”true”(不含双引号,所有字母皆为小写)。

样例输入1:
3 3 2
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 3 0 0 2
P1 1 0 2
样例输出1:
true

样例输入2:
3 3 2
P0 7 5 3 0 1 0
P1 3 2 2 2 0 0
P2 9 0 2 3 0 2
P3 2 2 2 2 1 1
P4 4 3 3 0 0 2
P4 3 4 0
样例输出2:
false

参考代码


import java.util.*;

public class Main{
/*
3 3 2
p0 7 5 3 0 1 0
p1 3 2 2 2 0 0
p2 9 0 2 3 0 2
p3 2 2 2 2 1 1
p4 4 3 3 0 0 2
p1 1 0 2

true

3 3 2
p0 7 5 3 0 1 0
p1 3 2 2 2 0 0
p2 9 0 2 3 0 2
p3 2 2 2 2 1 1
p4 4 3 3 0 0 2
p4 3 4 0

false
 */
	static int ava[]=new int[3];//记录可利用的a,b,c三种资源,ava[]大小为3
	static int max[][]=new int[5][3];//记录最大所需资源
	static int all[][]=new int[5][3];//记录已分配资源
	static int need[][]=new int[5][3];//记录还需分配的资源
	static int req[]=new int[3];//记录提出申请的资源
	static boolean finish[]=new boolean[5];//记录各个作业是否处于安全状态
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       Scanner sc=new Scanner(System.in);
       //记录作业名及作业ID,后续分配资源时,可通过hashmap直接拿到作业的id,分配资源
       HashMap<String,Integer> map=new HashMap<>();
       for(int i=0;i<3;i++)
       {
    	   ava[i]=sc.nextInt();
       }
       for(int i=0;i<5;i++)
       {
    	   String name=sc.next();
    	   max[i][0]=sc.nextInt();
    	   max[i][1]=sc.nextInt();
    	   max[i][2]=sc.nextInt();
    	   all[i][0]=sc.nextInt();
    	   all[i][1]=sc.nextInt();
    	   all[i][2]=sc.nextInt();
    	   need[i][0]=max[i][0]-all[i][0];
    	   need[i][1]=max[i][1]-all[i][1];
    	   need[i][2]=max[i][2]-all[i][2];
    	   map.put(name, i);
       }
       //取出需分配资源的作业ID
       int t=map.get(sc.next());
       for(int i=0;i<3;i++)
       {
    	   req[i]=sc.nextInt();
       }
       //如果需分配的资源大于可利用资源,或者大于还需分配的资源,返回false
       if(req[0]>ava[0]||req[1]>ava[1]||req[2]>ava[2]||req[0]>need[t][0]||req[1]>need[t][1]||req[2]>need[t][2])
       {
    	   System.out.print("false");
       }else {
    	   //更新分配资源的作业,分配的资源及还需分配的资源,更新可利用资源
    	   ava[0]-=req[0];
    	   ava[1]-=req[1];
    	   ava[2]-=req[2];
    	   need[t][0]-=req[0];
    	   need[t][1]-=req[1];
    	   need[t][2]-=req[2];
    	   all[t][0]+=req[0];
    	   all[t][1]+=req[1];
    	   all[t][2]+=req[2];
    	   for(int i=0;i<5;i++)
    	   {
    		   for(int j=0;j<5;j++)
    		   {
    			   //如果该作业未被处理过,且可利用资源大于等于还需分配资源
    			   if(!finish[j]&&ava[0]>=need[j][0]&&ava[1]>=need[j][1]&&ava[2]>=need[j][2])
    			   {
    				   finish[j]=true;
    				   ava[0]+=all[j][0];//回收分配的资源
    				   ava[1]+=all[j][1];
    				   ava[2]+=all[j][2];
    			   }
    		   }
    	   }
    	   for(int i=0;i<5;i++)
    	   {
    		   if(!finish[i])
    		   {
    			   System.out.print("false");
    			   return;
    		   }
    	   }
    	   System.out.print("true");
       }
	}

}



存储管理—可变分区存储管理方式的最佳适应、下次适应、最差适应分配算法

问题描述:当采用可变分区分配方案对1024KB的内存进行管理时,要求输入多个进程已经占用分区信息、一个进程内存请求以及所选用的分配算法,输出显示分配给进程的分区信息。

输入格式:程序要求输入4行,以回车符号作为分隔,第一行是一个整数n(4>n>0),表示进程已经占用分区的数量;第二行是2n个整数,依次按地址递增对应第一行n个进程已经占用分区的起始地址和存储容量(单位为KB)。第三行是三个整数,表示进程申请的内存空间大小(存储容量单位为KB);第四行是一个字符串,用”BEST”、 ”NEXT”、 ”WORST” (不含双引号,所有字母皆为大写)分别表示所选用的最佳适应、下次适应和最差适应分配算法。

输出格式:输出三个整数或字符串”false”(不含双引号,所有字母皆为小写),分别表示给进程所分配分区的起始地址;若某进程分配失败,则用”false”表示(不含双引号,所有字母皆为小写)。

样例输入1:
1
50 100
20 20 80
BEST
样例输出1:
0 20 150

样例输入2:
1
300 100
400 500 100
WORST
样例输出2:
400 false 0

参考代码

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {
/*
1
50 100
20 20 80
BEST

0 20 150

1
300 100
400 500 100
WORST

400 false 0

1
10 110
30 30 80
NEXT

120 150 180

 */
	public static class zone{
		int start;//起始地址
		int size;//大小
		String state;//状态
		int num;//-1表示空闲
		public zone(int start,int size,int num)
		{
			this.start=start;
			this.size=size;
			this.num=num;
			this.state="empty";
		}
	}
	static int ans[]=new int[3];//记录结果
	static int m;//记录结果的下标
	static int allsize=1024;//记录作业最大的内存空间
	static LinkedList<zone> freezones=new LinkedList<>();//记录空闲区
	static int t;//用于NEXT,记录上一次访问的空闲区的下标
	static int k;//记录地址
	//BEST
	public static void findfreezone(int size)
	{
		int min=Integer.MAX_VALUE;//记录最小的满足大于题给size的空闲区长度
		int mindex=-1;//记录最小的满足大于题给size的空闲区的下标
		boolean flag=false;//判断是否找到了空闲区
		for(int i=0;i<freezones.size();i++)
		{
			if(freezones.get(i).state.equals("empty")&&freezones.get(i).size>size)
			{       //区域处于空闲"empty",大小大于size
				if(freezones.get(i).size<min)
				{
				mindex=i;
				min=freezones.get(i).size;
				flag=true;
				}
			}
		}
		if(flag)
		{
			allocation(size,mindex,freezones.get(mindex));//分配空间
			ans[m++]=freezones.get(mindex).start;//记录分配区域的首地址
		}else {
			ans[m++]=-1;
			//-1表示未找到空闲区,最后结果返回false
		}
	}
	//分配空闲空间
	public static void allocation(int size,int index,zone freezone)
	{
		//开辟新的空闲空间,空间的下标为之前的空间下标+1
		zone newzone=new zone(freezone.start+size,freezone.size-size,-1);
		freezones.add(index+1,newzone);
		freezone.size=size;
		freezone.state="full";
		//将已占用的空间状态置为full,占满状态
	}
	//Worst
	public static void findfreezone2(int size)
	{
		int max=-1;
		int maxdex=-1;
		boolean flag=false;
		for(int i=0;i<freezones.size();i++)
		{
			if(freezones.get(i).state.equals("empty")&&freezones.get(i).size>size)
			{
				if(freezones.get(i).size>max)
				{
				maxdex=i;
				max=freezones.get(i).size;
				flag=true;
				}
			}
		}
		if(flag)
		{
			allocation(size,maxdex,freezones.get(maxdex));
			ans[m++]=freezones.get(maxdex).start;
		}else {
			ans[m++]=-1;
		}
	}
	//NEXT
	public static void  findfreezone1(int size)
	{
		int min=Integer.MAX_VALUE;
		int mindex=-1;
		boolean flag=false;
		for(int i=t;i<freezones.size();i++)
		{
			if(freezones.get(i).state.equals("empty")&&freezones.get(i).size>size)
			{
				mindex=i;
				t=mindex;
				min=freezones.get(i).size;
				flag=true;
			}
		}
		if(flag)
		{
			allocation(size,mindex,freezones.get(mindex));
			ans[m++]=freezones.get(mindex).start;
		}else {
			ans[m++]=-1;
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Scanner sc=new Scanner(System.in);
      int n=sc.nextInt();
      int a[]=new int[3];
      boolean b[]=new boolean[1024];
      while(n-->0)
      {
    	  int start=sc.nextInt();
    	  int size=sc.nextInt();
          for(int i=start;i<start+size;i++)
          {
        	  //将占满的空间置为true
        	  b[i]=true;
          }
      }
      int c=0,v = 0,flag=0;
      //c记录空闲区的长度,v记录空闲区的首地址,flag为标志位
      for(int i=0;i<1024;i++)
      {
          if(!b[i])
          {
        	  if(flag==0)
        	  {
        	  v=i;
        	  flag=1;
        	  }
        	  //如果b[i]空闲,记录首地址v,c自增到空闲区间长度,flag置为1,
        	  c++;
        	  if(v+c<1024&&b[v+c])
        	  {
        		  freezones.add(new zone(v,c,-1));
        		  //将空闲的区域添加到空闲集合
        		   i=v+c;
        		   flag=0;
        		   c=0;
        	  }
        	  //添加结尾的空闲空间
        	  if(v+c==1023&&!b[v+c])
        	  {
        		  freezones.add(new zone(v,c,-1));
        	  }
          }
      }
      for(int i=0;i<3;i++)
      {
    	  a[i]=sc.nextInt();
      }
      String s=sc.next();
      if(s.equals("BEST"))
      {
    	  for(int i=0;i<3;i++)
    	  {
    		  findfreezone(a[i]);
    	  }
      }else if(s.equals("NEXT"))
      {
    	  for(int i=0;i<3;i++)
    	  {
    		  findfreezone1(a[i]);
    	  }
      }else {
    	  for(int i=0;i<3;i++)
    	  {
    		  findfreezone2(a[i]);   
    	  }
      }
      for(int i=0;i<3;i++)
      {
    	  if(ans[i]!=-1)
    	  {
    		  System.out.print(ans[i]+" ");
    	  }else {
    		  System.out.print("false"+" ");
    	  }
      }
	}

}

存储管理—FIFO页面替换算法计算中断次数

问题描述:在请求分页式存储管理方式中,要求输入一个对5个页面的访问序列,输出当系统分配给进程物理页框数为m个时,按照FIFO页面替换算法的缺页中断次数(假设初始时页框均为空)。

输入格式:程序要求输入3行,以回车符号作为分隔,第一行是一个整数n,表示页面访问序列中访问页面的次数;第二行是n个整数,数之间以空格作为分隔,表示页面访问序列。第三行是一个整数m,表示系统分配给进程物理页框数。

输出格式:输出一个整数,表示缺页中断次数。

样例输入1:
12
4 3 2 1 4 3 5 4 3 2 1 5
3
样例输出1:
9

样例输入2:
12
4 3 2 1 4 3 5 4 3 2 1 5
4
样例输出2:
10

参考代码


import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Scanner;

public class Main {
/*
12
4 3 2 1 4 3 5 4 3 2 1 5
3

9

12
4 3 2 1 4 3 5 4 3 2 1 5
4

10
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n+1];
        for(int i=1;i<=n;i++)
        {
        	a[i]=sc.nextInt();
        }
        int k=sc.nextInt();//记录物理页面框数
        int count=0;//记录结果
        Deque<Integer> q=new ArrayDeque<>();//创建双端队列用来处理作业的进出
        for(int i=1;i<=n;i++)
        {
        	//如果页面已满,且进入了新的序列,则需要将队首的序列移除,将新序列添加到队尾,count++
        	if(q.size()>=k&&!q.contains(a[i]))
        	{
        		q.pollFirst();
        		q.addLast(a[i]);
        		count++;
        	}else {
        		//起初时页面不满,将访问序列添加到队列中,count++
        		if(q.size()<k&&!q.contains(a[i]))
        		{
        	    q.add(a[i]);
        		count++;
        		}

        	}
        }
        System.out.print(count);
	}

}

带存储管理的处理器调度4

问题描述:现有一个内存为100K的采用位示图进行页面管理的道数不受限制的多道程序设计系统,若作业调度采用高优先级(优先数越大优先级越大)调度算法(如果遇到优先级一样且只能调入一道作业时,按照输入顺序选择调度对象。),进程调度采用非剥夺式的SJF调度算法(如果遇到运行时间相同的进程,按照输入顺序选择调度对象。)。要求输入3个进程信息,输出当三个作业同时提交进入调度时进程的运行顺序。

输入格式:程序要求输入3行,以回车符号作为分隔,每行有4个数据,以空格作为分隔。首先输入一个字符串(长度小于等于10),为进程名;第2个数据类型为整型,表示进程所需的内存空间;第3个数据类型为整型,表示进程的运行时间;第4个数据类型为整型,表示进程的优先数。

输出格式:输出1行,M个字符串,字符串之间用空格作为分隔。

样例输入1:
P1 20 2 1
P2 60 3 2
P3 30 4 3
样例输出1:
P2 P1 P3

样例输入2:
P1 80 2 2
P2 30 5 3
P3 40 3 1
样例输出2:
P3 P2 P1

参考代码

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;


public class Main {
/*
p1 20 2 1
p2 60 3 2
p3 30 4 3

p2 p1 p3

p1 80 2 2
p2 30 5 3
p3 40 3 1

p3 p2 p1

p1 20 2 1
p2 60 3 2
p3 10 4 3

p1 p2 p3
	 */
	public static class node{
		String name;//作业名
		int space;//内存空间
		int time;//运行时间
		int prior;//优先级
		int rank_prior;//优先级排名
		int ready;//未进入为0,进入为1,运行为2
		public node(String name,int space,int time,int prior,int rank_prior,int ready)
		{
			this.name=name;
			this.space=space;
			this.time=time;
			this.prior=prior;
			this.rank_prior=rank_prior;
			this.ready=ready;
		}
	}
	static List<node> list;
	//用来排序作业的优先级排名
	public static void check()
	{
		if(list.get(0).prior>=list.get(1).prior)
		{
			list.get(0).rank_prior++;
		}else {
			list.get(1).rank_prior++;
		}
		if(list.get(0).prior>=list.get(2).prior)
		{
			list.get(0).rank_prior++;
		}else {
			list.get(2).rank_prior++;
		}
		if(list.get(1).prior>=list.get(2).prior)
		{
			list.get(1).rank_prior++;
		}else {
			list.get(2).rank_prior++;
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	     Scanner sc=new Scanner(System.in);
	     list=new ArrayList<>();
		 int allspace=100;//页面内存
		 int space=0;//已用空间
	     for(int i=0;i<3;i++)
	     {
	    	 String name=sc.next();
	    	 int space1=sc.nextInt();
	    	 int time=sc.nextInt();
	    	 int prior=sc.nextInt();
	    	 list.add(new node(name,space1,time,prior,1,0));
	     }
	     int min=0,min_dex = 0;//min_dex记录运行的作业的下标
	     check();
	     //每次打印一个作业名,三层for循环
	     for(int j=0;j<3;j++)
	     {
	    	 //每次都从优先级排名最大的作业开始
	    	 for(int i=3;i>0;i--)
	    	 {
	    		 for(int k=0;k<3;k++)
	    		 {
	    			 //如果优先级排名最大,内存空间能容纳,未被访问过
	    			 if(list.get(k).rank_prior==i&&list.get(k).space+space<=allspace&&list.get(k).ready==0)
	    			 {
	    				 space+=list .get(k).space;//更新可用空间
	    				 list.get(k).ready=1;//更新已经进入的作业状态
	    			 }
	    		 }
	    	 }
	    	 //找出进入内存的运行时间最短的作业的下标
	    	 min=1000;
	    	 for(int i=0;i<3;i++)
	    	 {
	    		 if(min>list.get(i).time&&list.get(i).ready==1)
	    		 {
	    			 min=list.get(i).time;
	    			 min_dex=i;
	    		 }
	    	 }
	    	 space-=list.get(min_dex).space;//运行完释放内存空间
	    	 list.get(min_dex).ready=2;//该过程已运行
	    	 System.out.print(list.get(min_dex).name+" ");
	     }
	}

}


驱动调度—采用电梯调度算法排列出磁盘请求响应次序

问题描述:要求输入一个柱面访问请求序列以及当前磁头所在柱面号和移动方向,输出采用电梯调度算法时移动臂响应的柱面访问序列。

输入格式:程序要求输入3行,以回车符号作为分隔,第一行是2个整数n、m,之间用空格隔开,n表示当前磁头所在的柱面号;m表示第二行输入m个数;第二行是m个整数,数之间以空格作为分隔,表示柱面访问请求序列;第三行是数字-1或1,当为-1时表示移动臂向柱面号减小方向移动,当为1时表示移动臂向柱面号增大方向移动。

输出格式:输出m个整数,数之间以空格作为分隔,采用电梯调度算法时移动臂响应的柱面访问序列。

样例输入1:
15 10
24 38 2 110 43 36 5 11 6 180
-1
样例输出1:
11 6 5 2 24 36 38 43 110 180

样例输入2:
15 10
24 38 2 110 43 36 5 11 6 180
1
样例输出2:
24 36 38 43 110 180 11 6 5 2

参考代码

import java.util.Scanner;

public class Main {
/*
15 10
24 38 2 110 43 36 5 11 6 180
-1

11 6 5 2 24 36 38 43 110 180

15 10
24 38 2 110 43 36 5 11 6 180
1
 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
     Scanner sc=new Scanner(System.in);
     int n=sc.nextInt();
     int m=sc.nextInt();
     int a[]=new int[m];
     for(int i=0;i<m;i++)
     {
    	 a[i]=sc.nextInt();
     }
     int k=sc.nextInt();
     for(int i=0;i<m-1;i++)
     {
    	 for(int j=i+1;j<m;j++)
    	 {
    		 if(a[i]>a[j])
    		 {
    			 int temp=a[i];
    			 a[i]=a[j];
    			 a[j]=temp;
    		 }
    	 }
     }
     int t=0;
     for(int i=0;i<m;i++)
     {
    	 if(a[i]>n)
    	 {
    		 t=i-1;
    		 break;
    	 }
     }
     if(k==-1)
     {
    	 for(int i=t;i>=0;i--)
    	 {
    		 System.out.print(a[i]+" ");
    	 }
    	 for(int i=t+1;i<m;i++)
    	 {
    		 System.out.print(a[i]+" ");
    	 }
     }else {
    	 for(int i=t+1;i<m;i++)
    	 {
    		 System.out.print(a[i]+" ");
    	 }
    	 for(int i=t;i>=0;i--)
    	 {
    		 System.out.print(a[i]+" ");
    	 }
     }
	}

}

📑文章末尾

在这里插入图片描述

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>