湖北师范大学操作系统实验（java版）

已于 2023-11-23 10:34:19 修改
阅读量3.1k 收藏 41
点赞数 17
文章标签： java 算法 数据结构
于 2023-05-19 21:13:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61494821/article/details/130773980
版权

📑前言

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

🎬作者简介：大家好，我是听风与他🥇
☁️博客首页：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]+" ");
    	 }
     }
	}

}

📑文章末尾

在这里插入图片描述

听风与他
关注
  • 17
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
湖北师范大学——操作系统实训题目
qq_54403943的博客
06-20 4855
仅供参考，有更好的方法请评论，有错误请指出，谢谢！问题描述：要求输入3个进程的信息，假设这些进程均是在0时刻同时到达，若进程调度采用非剥夺式静态优先级（优先数数值大的表示优先级比较高；如果遇到优先级一样，按照输入顺序执行。），计算并输出平均作业周转时间。输入格式：程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的优先数，第3个数据类型为整型，表示进程的运行时间。输出格式：输出结果为一个浮点数，保留到小数点后
湖北师范大学——操作系统实训（java版）
ChEnylnti的博客
01-12 1504
湖北师范大学——操作系统实训（java版）
湖北师范大学－操作系统实验
weixin_73236460的博客
05-27 586
输入格式：程序要求输入3行，以回车符号作为分隔，每行有4个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10）为进程名，第2个数据类型为整型，表示进程的进入时刻，第3个数据类型为整型，表示进程的运行时间，第4个数据类型为整型，表示进程的优先数。问题描述：假设系统中有A、B、C三类资源，且有四个并发进程，要求输入资源总量Resource，以及每个进程运行所需的资源总量Claim和已经分配得到的资源量Allocation，利用银行家算法判断当前状态是否为安全状态，若为安全状态则给出一个安全序列。
【操作系统】题目2：进程调度2-最高响应比优先计算每个作业的周转时间
m0_68259809的博客
02-22 1535
操作系统最高响应比优先计算每个作业的周转时间代码求解。
操作系统之调度算法（学习笔记）
m0_63094069的博客
03-23 4694
操作系统调度算法学习笔记，若有需要可去B站学习王道计算机考研课 操作系统
湖北师范大学计信2018届操作系统实训（参考答案）
小小怪的博客
05-21 2421
第一题问题 A: 各位同学请先完成此题以规范你们的语法 参考代码（Java）： package 问题A_各位同学请先完成此题以规范你们的语法; import java.util.Scanner; /** * @author 作者 : 吴泽胜 * @createDate 创建时间：2020-5-21 上午11:19:35 */ public class Main { public static void main(String[] args) { // TODO Auto-gene.
湖北师范大学Java实验五
柠檬喝汽水的博客
08-01 548
Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结 果仍是一个复数值，返回给此方法的调用者。6. 编写程序使用复数类Complex验证两个复数 2+2i 和3+3i 相加产生一个新的复数5+5i。String toString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中 a 和 b分别为实部和虚部的数据。3. 编写Java程序模拟简单的计算器。（2）按压操作函数void knock()，将penPoint置反。
基于Java的湖北师范大学科研管理网站设计源码
05-28
本项目是基于Java的湖北师范大学科研管理网站设计源码，包含937个文件，其中包括483个Java源文件、137个PNG图像文件、89个Vue组件文件、85个XML配置文件、62个JavaScript文件、26个Markdown文档、12个SVG文件、8个...
湖北省临床检验网络版EQA操作系统使用说明.docx
11-17
湖北省临床检验网络版EQA操作系统使用说明.docx
湖北汽车工业学院Java实验一 Java编程环境使用
04-02
保存资源，方便自己和他人
湖北汽车工业学院《数据库实现》第二次实验 JAVA GUI 学生信息管理系统 实验教师:齐心
10-02
1、主要包含湖北汽车工业学院《数据库实现》这门课程的实验教学代码。汽院学子可直接下载后解压缩...4、适用于湖北汽车工业学院第二次实验 学生管理系统 5、后续实验将会在实验前上传公开，有需要的同学可关注此账号。
湖北师范大学高等数学（2）期末试卷A卷.pdf
01-09
**湖北师范大学高等数学（2）期末试卷A卷分析** 这份试卷是针对湖北师范大学学生的高等数学（2）课程的期末考试，主要涵盖了第7至12章的内容。试题分为选择题、判断题、填空题、计算题和应用题五大类型，全面测试了...
操作系统实验
foxmaxiaoyu的博客
05-18 3449
每行有7个数据，以空格作为分隔。问题描述：假设系统中有A、B、C三类资源，且有五个并发进程，要求输入当前系统可用资源量Available，以及每个进程运行所需的资源总量Claim、已经分配得到的资源量Allocation和进程的资源申请。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的进入时刻，第3个数据类型为整型，表示进程的运行时间。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的优先数，第3个数据类型为整型，表示进程的运行时间。
《操作系统》第五章——存储器管理作业
渣渣修炼记
04-05 5881
存储器管理课后作业
最高响应比优先算法（HRRF）及例题详解
热门推荐
m0_56578216的博客
06-02 4万+
最高响应比优先算法（HRRF）：最高响应比优先算法是介于先来先服务算法（FCFS）和最短作业优先算法（SJF）之间的一种算法，它既考虑了作业的等待时间，又考虑了作业的处理时间。调度规则：响应比最高的作业先运行。优点：HRRF对于作业的时间分配比较均匀，既照顾了短作业，又不至于使长作业等待时间过长。缺点：HRRF每次计算响应比都会花费一定的时间，即时间开销。其性能比SJF算法略差。响应比的计算： 响应比=作业周转时间/作业处理时间 =（作业等待时间+作业处理时间）/作业处
操作系统总结之内存管理（除虚拟内存管理）
Tattoo的博客
07-02 2596
1 存储器的层次结构 CPU 寄存器 寄存器 主存 高速缓存 主存 磁盘缓存 辅存 磁盘 可移动存储介质 寄存器，高速缓存，主存，磁盘缓存属于操作系统存储管理，掉电后其信息不再存在 辅存和可移动存储介质 属于设备管理（因此会涉及中断，设备驱动程序和物理设备的运行），存储的信息被长期保存 1.1 主存储器和寄存器 主存储器 用于保存进程运行时的程序和数据，...
湖北师范大学Java实验三
柠檬喝汽水的博客
07-29 149
第五个是按位或运算符，即如果两个相应的二进制位中只要有一个1，则该位的结果值为1，否则为0，所以结果为11111111111111111111111111110110。第七个是按位异或运算符，即如果两个相应的二进制位相同，则该位的结果值为0，否则为1，所以结果为11111111111111111111111111100010。第三个是按位与运算符，即如果两个相应的二进制位都为1，则该位的结果值为1，否则为0，所以结果为10100。逻辑左移4位，最高位缺失4位最低位补4个0，对应的十进制为-
可变分区存储管理实验报告总结_可变分区存储管理+实验报告+程序+设计思路和感悟概要...
weixin_39708737的博客
12-19 719
实验题目：可变分区存储管理一、实验目的可变分区存储管理方式是操作系统中存储管理的重要方式，其主要思想是用户作业进行连续存储，每次按照用户的请求，如果内存中有能满足用户作业大小的空闲区，就采用不同的算法分配给用户，否则，不分配，可变分区容易产生外零头。分区分配算法包括最佳适应算法、最坏适应算法、首次适应算法等。通过本实验可加深学生对存储器管理方式的把握以及分配算法的理解，并提高程序设计的能力。二、实...
java学习----递归
最新发布
qq_56798493的博客
07-13 162
【代码】java学习----递归。
湖北师范大学操作系统实验
05-12
湖北师范大学操作系统实验一般包括以下内容： 1. 熟悉Linux系统的安装和基本操作； 2. 熟悉Linux系统的文件系统结构和文件管理； 3. 熟悉Linux系统下的进程管理和进程通信机制； 4. 熟悉Linux系统下的线程管理和线程同步机制； 5. 掌握Linux系统下的网络编程和Socket编程； 6. 理解Linux系统的设备驱动程序编写和设备管理； 7. 实现一个简单的操作系统内核。 以上是操作系统实验的一些常见内容，具体内容可能根据不同的课程和教师的要求有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

听风与他

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值