其他分享
首页 > 其他分享> > X32专项练习部分02

X32专项练习部分02

作者:互联网

X32专项练习部分02

循环队列中的元素个数

		/*
        设顺序循环队列Q[0: M-1]的头指针和尾指针分别为F和R.
        告诉你索引最高为6
        循环队列固定长度为7
        头指针F总是指向队头元素的前一位置.尾指针R总是指向队尾元素的当前位置.
        则该循环队列中的元素个数为()
        (R-F+M)%M
        R-F
        (F-R+M)%M
        F-R

        由画图和赋值的方法就可以做出来
        假设
        循环队列固定长度为7,M = 7
        头指针指向索引3,F = 3,也就是说当前循环队列是从第4个元素开始加的
        尾指针指向索引0,R = 0
        带入A选项
        (0 - 3 + 7) % 7 = 4
        这是求循环队列剩余元素的常用办法

		如果F指向头元素的位置
        R指向尾元素下一个位置
            (r-f+MAX)%MAX
        R如果指向尾元素
            (r-f+MAX+1)%MAX
         */

包机制

/*
涉及包机制
要导入java/awt/event下面的所有类,叙述正确的是?()

    正确答案: C
    import java.awt.*和import java.awt.event.*都可以
    只能是import java.awt.*
    只能是import java.awt.event.*
    import java.awt.*和import java.awt.event.*都不可以

说明:
    java.awt.*是导入java\awt包下所有的类,并不包括其子包下的类。
    java.awt.event.*才能导入java\awt\event包下的类。
 */

接口

class A implements B {
    public static void main(String args[]) {
        int i;
        A a1 = new A();
        i = a1.k;
        System.out.println("i=" + i);
    }
}

interface B {
    int k = 10;
}
/*
上述程序的输出结果是
i = 10
说明:
    在接口里面的变量默认都是public static final的,
    它们是公共的,静态的,最终的常量
    相当于全局常量,可以直接省略修饰符
    实现类可以直接访问接口中的变量

    一个类实现某个接口时,该类将会获得接口中定义的变量、抽象方法等
    因此可以把实现接口理解为一种特殊的继承,相当于实现类继承了一个接口
补充:
	但是所有的全局变量是有默认值不会报错的,全局变量在类初始化的时候会被虚拟机	赋默认值,而局部变量却不会。
	如果只是单纯的定义为什么不会报错呢?只定义不使用没有被压入栈中,所有的报错都是在栈中产生的。

/*
再补充一下接口问题:
如果是Java 7以及以前的版本,那么接口中可以包含的内容有:1. 常量;2. 抽象方法
如果是Java 8,还可以额外包含有:3. 默认方法;4. 静态方法
如果是Java 9,还可以额外包含有:5. 私有方法
普通类可以实现接口,并且可以实现多个接口,但是只能继承一个类,这个类可以是抽象类也可以是普通类
如果继承抽象类,必须实现抽象类中的所有抽象方法,否则这个普通类必须设置为抽象类;

D项: abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。
is-a,理解为是一个,代表继承关系。 如果A is-a B,那么B就是A的父类。
like-a,理解为像一个,代表组合关系。 如果A like a B,那么B就是A的接口,A实现了B的接口。
has-a,理解为有一个,代表从属关系。 如果A has a B,那么B就是A的子类。
 */
 */

多线程中断异常

/*
下面哪个行为被打断不会导致InterruptedException:(E)?

Thread.join
Thread.sleep
Object.wait
CyclicBarrier.await
Thread.suspend

答案:
说明:
    文档里面写的:当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时
    抛出该异常

    CyclicBarrier是一个屏障类,它的await方法可以简单的理解为:
    等待多个线程同时到达之后才能继续进行
    suspend()方法已过时,严重遭到但对
        是因为 suspend() 在导致线程暂停的同时,并不会去释放任何锁资源。其他线程都无法访问被它占用的锁
        直到对应的线程执行 resume() 方法后,被挂起的线程才能继续,从而其它被阻塞在这个锁的线程才可以继续执行
    抛InterruptedException的代表方法有:
    java.lang.Object 类的 wait 方法
    java.lang.Thread 类的 sleep 方法
    java.lang.Thread 类的 join 方法
 */

泛型转让关系

/*
class A {}
class B extends A {} B <= A
class C extends A {} C <= A
class D extends B {} D <= B
下面的哪4个语句是正确的
正确答案: A C D G
The type List<A>is assignable to List. 正确 is assignable to 就是可以赋值的意思 表示A可以赋值给List
The type List<B>is assignable to List<A>.
The type List<Object>is assignable to List<?>. 正确
The type List<D>is assignable to List<?extends B>. 正确
The type List<?extends A>is assignable to List<A>.
The type List<Object>is assignable to any List reference.
The type List<?extends B>is assignable to List<?extends A>. 正确

说明:
    1. 只看尖括号里边的!!明确点和范围两个概念
    2. 如果尖括号里的是一个类,那么尖括号里的就是一个点,比如List<A>,List<B>,List<Object>
    3. 如果尖括号里面带有问号,那么代表一个范围,<? extends A> 代表小于等于A的范围
       <? super A>代表大于等于A的范围,<?>代表全部范围
    4. 尖括号里的所有点之间互相赋值都是错,除非是俩相同的点
    5. 尖括号小范围赋值给大范围,对,大范围赋值给小范围,错
       如果某点包含在某个范围里,那么可以赋值,否则,不能赋值
    6. List<?>和List 是相等的,都代表最大范围

    public static void main(String[] args) {
		List<A> a;
		List list;
		list = a;   //A对,因为List就是List<?>,代表最大的范围,A只是其中的一个点,肯定被包含在内
		List<B> b;
		a = b;      //B错,点之间不能相互赋值
		List<?> qm;
		List<Object> o;
		qm = o;     //C对,List<?>代表最大的范围,List<Object>只是一个点,肯定被包含在内
		List<D> d;
		List<? extends B> downB;
		downB = d;  //D对,List<? extends B>代表小于等于B的范围,List<D>是一个点,在其中
		List<?extends A> downA;
		a = downA;  //E错,范围不能赋值给点
		a = o;      //F错,List<Object>只是一个点
		downA = downB;  //G对,小于等于A的范围包含小于等于B的范围,因为B本来就比A小,B时A的子类嘛
	}
 */

链式队列入队操作序列

/*
设指针变量fron t 表示链式队列的队头指针,指针变量rear表示链式队列的队尾指针,
指针变量s指向将要入队列的结点X,则入队列的操作序列为()。

正确答案: C
front->next=s;front=s;
s->next=rear;rear=s;
rear->next=s;rear=s;
s->next=front;front=s;

已知s作为结点X的存储地址
先让rear的下一个指向目标变为s,再把rear更新为s
先赋值,再移动指针
注意:
1.本题是链式队列,大小不受限,对于链式队列,队尾指针指向队尾元素,且有rear->next = null
2.当s指向的元素入队时,需要指向的操作有rear->next = s; s = rear,
  我们可以想象成线性链表增加元素所需要执行的操作
3.注意不要和大小固定的顺序队列混淆
 */

双栈模拟队列的最大容量

/*
用俩个栈模拟实现一个队列,如果栈的容量分别是O和P(O>P),那么模拟实现的队列最大容量是多少?
正确答案: C
O+P
2O+1
2P+1
2O-1

题目所指的最大容量的情况是:
    O:n+1 - 2n+1
    P:1 - n
说明:
    此时缓冲栈P已经满了
    再次向O里面存取元素n+1 - 2n+1
    然后缓冲栈P进行出栈操作
    随后将存储栈O进行出栈
    对应P进行压栈
    存储栈O仅剩n+1
    而缓冲栈P为n+2 - 2n+1
    存储栈进行弹栈
    注意:此时存储栈栈帧数量>1,将无法满足按顺序出队
    所以容量最大为2P + 1

    参考:https://blog.csdn.net/MissingDi/article/details/104722020/
 */

队列应用:虚拟存储系统调入淘汰

/*
有一个虚拟存储系统,若进程在内存中占3页(开始时内存为空),若采用先进先出(FIFO)页面淘汰算法,当执行如下访问页号序列后1,2,3,4,5, 1,2,5,1,2,3,4,5,会发生多少缺页?
7
8
9
10
正确答案:D
这道题一开始我没看懂,看过解析后才理解
还是挺简单的
注意:前三页同样缺页,先调入的就先淘汰
遵循先进先出原则

1、 访问1,缺页,调入1,内存中为  1, ,;
2、 访问2,缺页,调入2,内存中为  1,2,;
3、 访问3,缺页,调入3,内存中为  1,2,3;
4、 访问4,缺页,调入4,淘汰1,内存中为 4,2,3;
5、 访问5,缺页,调入5,淘汰2,内存中为 4,5,3;
6、 访问1,缺页,调入1,淘汰3,内存中为 4,5,1;
7、 访问2,缺页,调入2,淘汰4,内存中为 2,5,1;
8、 访问5,不缺页,内存中为 2,5,1;
9、 访问1,不缺页,内存中为 2,5,1;
10、访问2,不缺页,内存中为 2,5,1;
11、访问3,缺页,调入3,淘汰5,内存中为 2,3,1;
12、访问4,缺页,调入4,淘汰1,内存中为 2,3,4;
13、访问5,缺页,调入5,淘汰2,内存中为 5,3,4;
 */

两端队列应用:输入输出受限

/*
若以1234作为双端队列的输入序列,则既不能由输入受限的双端队列得到,也不能由输出受限的双端队列得到的输出序列是()
正确答案: C
1234
4132
4231
4213

说明:
    双端队列是一种同时具有队列和栈的性质的一种数据结构,
    在队列的两头都可以进行插入和删除的操作;
    输入受限:
    就是限制一端只能进行插入操作
    输出受限
    就是限制一端只能进行删除操作

    由题意可以看出
    AB两个选项是输入受限,一端输入,就是左右两端交替输出
    D是输出受限,就是左右两端交替插入,一端输出
    只有C选项和上面两行不是一个类,怎么受限都不行
    参考https://www.nowcoder.com/questionTerminal/0dd2e77c466b4f0eac68130981ca2810
 */

总目录

标签:X32,02,java,队列,练习,List,内存,缺页,中为
来源: https://blog.csdn.net/m0_54608045/article/details/120592542