笔试题05

其他

1. 在【循环链表】中，只要指出表中任何一个结点的位置，就可以从它出发依次访问到表中其他所有结点。
2. 打电话使用的数据传输方式是【电路交换】，手机上网使用的数据传输方式是【分组交换】。
3. 后退N帧协议的发送窗口大小是【>1】，接收窗口的大小是【=1】。
4. 预防Ddos的方法可以有: 限制同时打开SYN半链接的数目。
5. export 用于修改环境变量，env 用于创建环境变量
6. 【拥有者|所属组|其他】(r: 可读(4)-w: 可写(2)-x: 可执行(1))

1. 一颗二叉树的叶子节点有5个，出度为1的结点有3个，该二叉树的结点总个数是？

叶子节点个数 = 5 ，因为叶子节点个数=度为2的结点个数加1，所以
度为2的结点个数=5-1=4，
度为1的结点个数 = 3,
所以总个数 = 5 + 4 + 3 = 12

2. 权值分别为9、3、2、8的结点，构造一棵哈夫曼树，该树的带权路径长度是？

https://blog.csdn.net/lmh10621/article/details/76100381

          22
 
        /    \
 
      13      9
 
    /   \
 
   5     8
 
 /  \
 
2    3
WPL = 2*3 + 3*3 + 8*2 + 9*1 = 40

3. 协议分布

4. 各层物理设备分布

网络层以上：网关
网络层：路由器
数据链路层：网桥、交换器
物理层：中继器、集线器

5. TCP释放连接第二次挥手时ACK（1）,第三次挥手时ACK（1）

第一次挥手： 
Client ==【FIN=1, seq=X】==> Server
Client <==【ACK=1, ack=X+1, seq=V】== Server
第二次挥手
Client <==【ACK=1, ack=X+1, FIN=1, seq=U】== Server
Client ==【ACK=1, ack=U+1, seq=X+1】==> Server

6. MyISAM特性：

1:不支持事务、不具备AICD特性(原子性、一致性、分离性、永久性);
2:表级别锁定形式(更新数据时锁定整个表、这样虽然可以让锁定的实现成本很小但是同时大大降低了其并发的性能)；
3:读写相互阻塞(不仅会在写入的时候阻塞读取、还会在读取的时候阻塞写入、但是读取不会阻塞读取);
4:只会缓存索引(myisam通过key_buffer_size来设置缓存索引，提高访问性能较少磁盘IO的压力、但是只缓存索引、不缓存数据);
5:读取速度快、占用资源比较少;
6:不支持外键约束、只支持全文检索；
7:是MySQL5.5.5版本之前的默认存储引擎；

7. TRUNCATE、DELETE和DROP区别

1. 【本质上】DELETE是数据库操作语言会进入回滚日志中，TRUNCATE、DROP是数据库定义语言不会进入日志；
2. 【功能上】DELETE配合WHERE删除指定记录或不加WHERE删除所有记录但保留表的定义，TRUNCATE删除表中所有记录但保留表的定义，DROP删除表的内容和定义；
3. 【应用场景上】删除表中全部内容但不删除表的定义使用truncate，删除表中指定内容但不删除表的定义且进行日志记录使用DELETE，删除整张表的内容和定义使用DROP；
4. 【执行速度上】DROP > TRUNCATE > DELETE;

8. JAVA的类加载期负责整个生命周期内的class的初始化和加载工作，就虚拟机的规范来说，以下代码会输出什么结果？https://www.cnblogs.com/hgnulb/p/10298650.html

9. 编译器常量

10. 类加载器加载类的初始化

11. try{}catch(){}finally{}问题

public class Main {
 
    public static void main(String[] args) {
        System.out.print(fun1());
    }
 
    public static String fun1() {
        try {
            System.out.print("A");
            return fun2();
        } finally {
            System.out.print("B");
        }
    }
 
    public static String fun2() {
        System.out.print("C");
        return "D";
    }
}
//try中执行完return的语句后，不返回，执行finally块，
//finally块执行结束后，返回到try块中，返回try块中最后return的值

12. ArrayList初始10，每次扩容为原先的1.5倍

import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for(int i=0;i<100;i++){
            list.add("a");
        }
    }
}
JDK1.8中，执行以上程序后，该list进行了几次扩容？
//为10->15->22->33->49->73->109，故答案为6次。

13. 统计各部门平均年龄，其中三部门人员平均年龄分别为38岁、24岁、42岁。A和B 两部门人员平均年龄为30岁，B和C两部门人员平均年龄为34岁。这三个部门全体人员的平均年龄为多少岁？

利用十字交叉法算得A:B=3:4，B:C=4:5，故A:B:C=3:4:5，
最后利用平均数公式知平均年龄为（38×3+24×4+42×5）÷12=35

14. 数据结构复杂度

B+ 树插入操作平均时间复杂度是O(logn)，最坏时间复杂度是O(nlogn)

15. 入栈序列是：a1,a3,a5,a2,a4,a6,出栈序列是：a5,a4,a2,a6,a3,a1，则栈的容量最小是

1                         1
3                         1 3
5                         1 3 5
-                          1 3                       5
2                         1 3 2
4                         1 3 2 4
-                          1 3 2                   4
-                          1 3                      2
6                         1 3 6              
-                          1 3                      6
-                          1                         3
-                                                     1
D

16. 端口号处理相关命令

* 查看8080端口号是否被占用
netstat -atulnp | grep 8080
* 查看哪个进程占用8080端口号
lsof -i:8080
 
* 根据进程pid查看进程信息
ps -aux | grep [pid]

17. 已知二叉树的中序遍历结果为MFLEDABKCGHJI，后序遍历结果为FELMDKHGJICBA，则其先序遍历结果为

前：根->左->右
中: 左->根->右
后: 左->右->根

18. 为了解决进程间的同步和互斥问题，通常采用一种称为信号量机制的方法。若系统中有7个进程共享若干个资源R，每个进程都需要6个资源R，那么使系统不发生死锁的资源R的最少数目是【36】

用银行家算法计算死锁时，假设有m个共享资源，n个进程，每个进程所需的最大资源数为w，那么仅是m>n*(w-1)时，才会不死锁。如果每个进程所需的资源数不同，则先平均分配，
只要有一个进程满足了资源要求，就不会死锁。

不会发生死锁的资源数m > n * (w-1) = 7 * (6 - 1) = 7 * 5 = 35
最少： 36个

19. 若磁头的当前位置在第100磁道，现在有一磁盘读写请求序列如下：32,286,125,192,28,41,297,413,29,64,80,4。若采用最短寻道时间优先算法，则平均寻道长度是多少？

磁盘最短寻道时间优先算法：
从100开始依次搜索顺序：80，64，41，32，29，28，4，125，192，286，297，413
 寻道长：20+16+23+9+3+1+24+121+67+94+11+116 磁盘最短寻道时间优先算法：
从100开始依次搜索顺序：80，64，41，32，29，28，4，125，192，286，297，413
 寻道长：(20+16+23+9+3+1+24+121+67+94+11+116) / 12 = 42.08

20. 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        Integer num=null;
        if(!stack2.empty()){
            num=stack2.pop();
        }
        else{
            while(!stack1.empty()){
                num=stack1.pop();
                stack2.push(num);
            }
            if(!stack2.empty())
                num=stack2.pop();
        }
        return num;
    }
}

21. 上述代码能否保证所有Hello, DWD一定在Done All DWD之前输出？如果不能，请尽可能多的提供方法来保证

1.public static void main(String[] args) throws InterruptedException {
        final CountDownLatch countDownLatch=new CountDownLatch(10);
        for (int i=0;i<10;i++) {
                new Thread(()->{
                    System.out.println("hello DW");
                    countDownLatch.countDown();
                }).start();
        }
        countDownLatch.await();
        System.out.println("dfghj");
    }
 
 
 2.   public static void main(String[] args) throws InterruptedException {
        for (int i=0;i<10;i++) {
                new Thread(()->{
                    System.out.println("hello DW");
                }).start();
        }
        Thread.sleep(1000);
        System.out.println("dfghj");
    }
 
 
3. public static void main(String[] args) throws InterruptedException {
        List<Thread> list=new ArrayList<>();
        for (int i=0;i<10;i++) {
                Thread child = new Thread(()->{
                    System.out.println("hello DW");
                });
                list.add(child);
                child.start();
        }
        for (Thread thread:list) {
            thread.join();
        }
        System.out.println("dfghj");
    }
4. public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        final CyclicBarrier cyclicBarrier=new CyclicBarrier(10);
        for (int i=0;i<10;i++) {
                Thread child = new Thread(()->{
                    System.out.println("hello DW");
                    try {
                        cyclicBarrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } 
                });
                child.start();
                
        }
        cyclicBarrier.await();
        System.out.println("dfghj");
    }
 

22. 编程题

public static void main(String[] args){
    System.out.println(test());
}
public static int test(){
    try{
        int i = 1 / 0;
        return 1;
    }catch(Exception e){
        return 2;
    }finally{
        return 3;
    }
}
// 以上代码的输出结果是：3

23. 编程题

class A{
  static {
    System.out.println("AS");
  }
  
  public A(){
    System.out.println("AC");
  }
}
 
class B extends A{
    static {
      System.out.println("BS");
    }
 
    public B(){
      System.out.println("BC");
    }
}
 
public clsss Test3{
    public static void main(String[] args){
        new B();
        new B();
    }
}
输出内容：
AS 
BS 
AC 
BC 
AC 
BC
//【静态代码块只执行一次】
// 1. 父类静态域内容
// 2. 子类静态域内容
// 3. 父类普通代码
// 4. 父类构造代码
// 5. 子类普通代码
// 6. 子类构造代码