哔哩哔哩2019秋招技术岗（前端、运维、后端、移动端）第一套笔试题

1. 下面哪些项是TCP具有的能力？（A B D）

A. 有连接
B. 数据可靠传输
C. 数据按序到达
D. 端到端流量控制

解析：TCP数据报还要由下层的IP协议封装，由于IP数据报到达目的后可能顺序变乱，因此TCP报文顺序也可能变乱。因此到达目的后如果报文顺序混乱，TCP协议会进行排序。

2. 在公司局域网上ping www.bilibili.com 没有涉及到的网络协议是？（A）

A. TCP
B. DNS
C. ICMP
D. ARP

解析：域名DNS，ping指令ICMP协议发送（ICMP请求回显数据包），通过IP获取mac地址的ARP

3. 以下哪个数据结构底层是用红黑树实现的? (C)

A. vector
B. list
C. map
D. deque

解析：map 散列表+红黑树（jdk1.8）

4. 以下ip地址中不属于私网地址的是：（C）

A. 192.168.1.26
B. 172.21.213.56
C. 127.2.0.1
D. 10.1.1.200

解析：
IP地址分为5类，其中A，B，C三类中各保留了3个区域作为私网地址，也就是局域网用的，私网地址不能在公网上出现，只能用在内部网路中，所有的路由器都不能发送目标地址为私网地址的数据报。
私网地址是：
A类地址：10.0.0.0～10.255.255.255
B类地址：172.16.0.0 ～172.31.255.255
C类地址：192.168.0.0～192.168.255.255
127开头的ip地址是保留本地回环地址，不会出现在网络上的，不论是私网还是公网。

5. 以下排序算法中，最坏情况时间复杂度与其他选项不同的是（D）

A. 冒泡排序
B. 插入排序
C. 快速排序
D. 归并排序

解析：

6. 以下哪一项正则能正确的匹配网址: http://www.bilibili.com/video/av21061574 （B）

在这里插入图片描述

解析：
首先，^表示匹配输入的开始，$表示匹配输入的结束
每个选项从前向后看，http都能够严格匹配
?表示匹配某元素0次或1次，这里四个选项都没有问题，能够匹配0次或1次字符s
接下来:严格匹配，//严格匹配两个//
接着往下看，[]表示字符集合，它用在正则表达式中表示匹配集合中的任一字符
A D 选项中的 [a-zA-Z\d] 表示匹配一个小写字母或者大写字母或者数字
B C 选项中的 \w 表示匹配字母数字或下划线（注意这里比A D中能多匹配下划线类型）
+表示匹配某元素1次或多次，到这里四个选项都能够完美匹配字符www
.可以匹配除了换行符\n \r外的任何字符
接下来我们看选项A，bilibili com video av都严格匹配，而 \D 表示匹配一个非数字字符而非数字字符，av后的数字是无法匹配成功的，A错误
B选项，\d匹配数字，{m,n}表示最少匹配m次，最多匹配n次，/?能匹配末尾的0个或1个/字符，B正确
C选项，*表示匹配某元素0次或多次，但 \w 并不能匹配字符 /，C错误
D选项，前面都对，错在最后的/+至少要匹配一个/，而原字符串最后并没有/

7. 以下设计模式的应用场景中，属于代理模式的选项有（C D）

A. 树形结构的遍历
B. 产品簇创建场景
C. 防火墙
D. CopyOnWriteList

解析：
JUC中与ArrayList有关的线程安全容器类CopyOnWriteArrayList，在对数组进行remove()、clear()、set()和add()操作时，在方法里先用ReentrantLock加锁，再复制一个新数组，修改操作在新数组上完成，再将原数组指向到新数组中，最后解锁。这里的新数组就相当于一个代理

8. 由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（B）

A. -126
B. -125
C. -32
D. -3

解析：既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，原码中肯定是1所在的位数越高，值越小，而补码是由原码取反加1得到的，则在补码中1所在的位数一定要越低，即补码为1000 0011；由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125;

9. 深度为k的二叉树至多有几个结点（C）

A. 2^k
B. 2^(k-1)
C. 2^k-1
D. 2^k+1

解析：

10. 以下软件设计模式的应用场景中，属以下git命令中，用于显示工作区和当前分支文件的差异的命令是（D）

A. git diff
B. git diff HEAD HEAD^
C. git diff --cached
D. git diff HEAD

解析：
git diff：是查看 workspace 与 index 的差别的。
git diff --cached：是查看 index 与 local repositorty 的差别的。
git diff HEAD：是查看 workspace 和 local repository 的差别的。（HEAD 指向的是 local repository 中最新提交的版本）

11. 以下哪些技术属于局域网技术（A D）

A. FDDI
B. ATM
C. ISDN
D. 令牌环

解析：
局域网的类型很多，
若按网络使用的传输介质分类，可分为有线网和无线网；
若按网络拓扑结构分类，可分为总线型、星型、环型、树型、混合型等；
若按传输介质所使用的访问控制方法分类，又可分为以太网、令牌环网、FDDI网和无线局域网等。其中，以太网是当前应用最普遍的局域网技术。
ATM是Asynchronous Transfer Mode（ATM）异步传输模式的缩写，是实现B-ISDN的业务的核心技术之一。ATM是以信元为基础的一种分组交换和复用技术。（广域网）

12. 线程的哪些资源可以共享（A C）

A. 堆
B. 栈
C. 静态变量
D. 存储器

解析：
线程共享资源有：
1 . 堆由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的（16位平台上分全局堆和局部堆，局部堆是独享的）
2 . 全局变量它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的
3 . 静态变量虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的
4 . 文件等公用资源是共享的，使用这些公共资源的线程必须同步。Win32 提供了几种同步资源的方式，包括信号、临界区、事件和互斥体。

13. 下列哪个是建立TCP连接的正确流程：（A）

A. 客户端向服务器端发送SYN包；服务端向客户端发送SYN+ACK；客户端回复ACK。
B. 客户端向服务器端发送SYN包；服务端向客户端发送SYN+ACK。
C. 客户端向服务器端发送FIN；服务器端回复ACK，并进入wait状态；服务器端确认并发送FIN；客户端回复ACK。
D. 客户端向服务器端发送FIN；服务器端回复ACK，并进入wait状态；服务器端确认并发送FIN。

解析：
A 是TCP连接时的3次握手
C 是TCP断开时的4次挥手
有关SYN和ACK的部分：
https://blog.csdn.net/u014507230/article/details/45310847
https://blog.csdn.net/zzz_781111/article/details/4183743

14. 以下说法正确的是：（B）

A. 非静态方法的使用效率比静态方法的效率高。
B. 非静态方法不存在线程安全的问题。
C. 非静态方法可以直接通过类名.方法名的方法来调用。
D. 非静态方法中不可调用静态方法。

15. 两个人抛硬币，规定第一个抛出正面的人必须穿女装，请问先抛的人穿女装的概率多大？（C）

A. 1/2
B. 1/3
C. 2/3
D. 5/6

解析：

16. 有限状态自动机能识别（B）

A. 上下文无关文法
B. 正规文法
C. 上下文有关文法
D. 短语文法

解析：
A. 下推自动机识别上下文无关文法
B. 有限状态自动机识别正规文法
C. 线性有限状态机（LBA) 识别上下文有关文法
D. 图灵机识别短语文法
参考链接： https://blog.csdn.net/tang_huan_11/article/details/7670268

17. 按照二叉树的定义,具有3个结点的二叉树有几种。（C）

A. 3
B. 4
C. 5
D. 6

解析：

18. 无向图G=(V,E)，其中V={a,b,c,d,e,f} E={(a,b),(a,e),(a,c),(b,e),(c,f),(f,d),(e,d)} 对该图进行深度优先遍历,得到的顶点序列正确的是（D）

A. a,b,e,c,d,f
B. a,c,f,e,b,d
C. a,e,b,c,f,d
D. a,b,e,d,f,c

解析：
A.a,b,e,d,f,c(从a-b路线走)
B.a,c,f,d,e,b（从a-c路线走）
C.a,e,b,d,f,c或者a,e,d,f,c,b(从a-e路线走)

19. 如果文法G存在一个句子，满足下列条件之一时，则称该文法是二义文法。（B C D）

A. 该句子的最左推导与最右推导相同
B. 该句子有两个不同的最左推导
C. 该句子有两棵不同的最右推导
D. 该句子有两棵不同的语法树

解析：
参考链接：https://blog.csdn.net/qq_33230935/article/details/78108309

20. 设指针q指向单链表中结点A，指针p指向单链表中结点A的后继结点B，指针s指向被插入的结点X，则在结点A和结点B插入结点X的操作序列为（B）

A. s->next=p->next; p->next=-s;
B. q->next=s; s->next=p;
C. p->next=s->next; s->next=p;
D. p->next=s; s->next=q;

解析：
s->next=q->next;q->next=s

21. a - (b + c) * d + e / f 的逆波兰式是 abc+d*-ef/+

解析：
1、先根据表达式的运算法则的先后顺序进行树的构建（括号不参与构树）

2、逆波兰表达式也叫作后缀表达式通过树的后序遍历得到结果

22. 当前发送帧数据为101010，发送方和接收方约定除数为1101，用循环冗余算法进行封装后，接收方拿到的数据是 101010011

解析：
CRC算法原理：https://blog.csdn.net/u010190210/article/details/80707698

23. 一个完全二叉树有870个节点其叶子节点个数为 435

解析：
链接：
1层满二叉树节点数=2^1-1；
2层满 2^2-1;
…
9层满 2^9-1=511
10 1023
所以870个节点是一个10层的完全二叉树，且它的
第十层有870-511=359个叶子节点；
第九层有256个节点
其中180个节点有孩子节点（下一层的359个叶子）
剩下256-180=76个节点
总计：76+359=435各节点

24. 设某棵二叉树的中序遍历序列为cadb，前序遍历序列为acbd，这个二叉树的后序遍历序列是 cdba

解析：

25. 设一组初始关键字序列为(38,65,97,76,13,27,10)，则第3趟冒泡排序结束后的结果为 38,13,27,10,65,76,97

解析：
第1趟跑完
结果
[38, 65, 76, 13, 27, 10, 97]
第2趟跑完
结果
[38, 65, 13, 27, 10, 76, 97]
第3趟跑完
结果
[38, 13, 27, 10, 65, 76, 97]

26. 在TCP/IP网络中，TCP协议工作在传输层，FTP协议工作在应用层

解析：

参考链接：https://blog.csdn.net/qq_22238021/article/details/80279001

27. HTTP协议中的禁止访问(Forbidden)的状态码是 403

解析：
常见HTTP状态码
200 ok 服务器成功处理请求
301/302 重定向请求的URL已经转移
304 未修改客户缓存的资源是最新的客户端使用缓存内容
403 Forbidden 禁止。服务器拒绝请求
404 NotFound 未找到资源
405 Method Not Allowed 不允许使用的方法

28. 在SQL查询时，如果去掉查询结果中的重复组，需使用 distinct 参数

29. 执行C语言程序段“y=1; x=5; while(x–); y++;”后，y的值为 2

解析：
while后面有分号

30. 对下列递归函数 int f(int n) { return((n==0)?1:f(n-1)+2);}，函数调用f(3)的返回值是 7

解析：
f(3)=f(2)+2
f(2)=f(1)+2
f(1)=f(0)+2
f(0)=1
即 f(3)=1+2+2+2

31. 实现一个HTML语法检查器。HTML语法规则简化如下：

1. 标签必须闭合，可以由开始和结束两个标签闭合，如<div></div>，也可以自闭合，如<div />

2. 标签可以嵌套如<div><a></a></div>或者 <div><a/></div>，但是标签不能交叉：<div><a></div></a>是不允许的

3. 标签里可以有属性如<div id=“a<1”></div>，属性的规则是name=“任意非引号字符”，多属性声明之间必须有空格，属性声明不符合规则时，整段HTML都算语法错误输入文本只会出现字母a-z和<>"=

请用任意语言实现一个HTML语法检查器函数，有语法错误返回1，没有语法错误返回0

参考代码：
作者：邂逅的瞬间（牛客网）
代码（JAVA）：

import java.util.*;
import java.util.Stack;
 
public class Main{
 
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        int result = 1;
        if(solve(str)) result = 0;
        System.out.println(result);
    }
     
    public static boolean solve(String str){
        str = str.trim(); //消除前后的空格
        if(str == null && str.length() == 0) return false;
        Stack<String> stack = new Stack<>(); //记录标签的入栈顺序
        int i = 0;
        while(i < str.length()){
            if(i == 0 && str.charAt(i) != '<') return false; //第一个字符不是<，则表明不是以标签开始
            if(i == str.length() - 1 && str.charAt(i) != '>') return false; //最后的字符不是>，则表明不是以标签结束
            if(str.charAt(i) == '<'){
                int j = i + 1;
                //'<'之后如果是标签，紧跟在'<'之后的字符必定是a-z或者'/'
                if(j < str.length() && (str.charAt(j) >= 'a' && str.charAt(j) <= 'z' || str.charAt(j) == '/')){
                    //获取标签字符串<xx xx="">
                    boolean inStr = false; //是否处于字符串"里面
                    while(j < str.length()){
                        if(!inStr && str.charAt(j) == '>'){  //标签结束
                            if(!checkAtt(str.substring(i + 1, j), stack)) //传入的标签已经去除'<'和'>'字符
                                return false; //属性有语法错误
                            i = j;
                            break;
                        }
                        else if(str.charAt(j) == '"') inStr = !inStr;
                        j++;
                    }
                }
            }
            i++;
        }
        if(stack.isEmpty()) return true;
        return false;
    }
     
    public static boolean checkAtt(String str, Stack<String> stack){  //处理标签里面的属性
        if(str == null && str.length() == 0) return true;
        int type = 0; //记录标签的类型，0为开始标签<x>，1为结束标签</x>,2为自闭合标签<x/>
        if(str.charAt(0) == '/'){  //判断是否是结束标签
            if(!(str.length() >= 2 && str.charAt(1) >= 'a' && str.charAt(1) <= 'z')) return false; //结束标签的'/'之后必须紧跟字母
            type = 1; //为结束标签
            str = str.substring(1);
        }
        str = str.trim(); //去除字符串后面的空格
        if(str.charAt(str.length() - 1) == '/'){ //判断是否是自闭合标签
            if(type == 1) return false; //不能同时为结束标签，又是自闭合标签
            type = 2;
            str = str.substring(0, str.length() - 1);// 去除最后的'/'
        }
        int i = 0;
        //获取标签的名字，并判断是否符合闭合规则
        while(i < str.length() && str.charAt(i) != ' ') i++;
        String name = str.substring(0, i);
        if(type == 0) stack.push(name);
        else if(type == 1){
            if(!stack.isEmpty() && stack.peek().equals(name)) stack.pop();
            else return false;
        }
        //判断其属性是否有语法错误
        boolean hasAtt = false; //判断该标签是否有属性，针对结束标签不能有属性
        boolean hasBlank = false; //判断属性name之前是否有空格
        while(i < str.length()){
            while(i < str.length() && str.charAt(i) == ' ') {hasBlank = true; i++;}
            while(i < str.length() && str.charAt(i) != '=' && str.charAt(i) != ' ') i++; //获取属性名字
            if(i < str.length() && str.charAt(i) == '='){ //如果没有'='说明不是属性，不进行处理
                i++;
                if(i >= str.length() || str.charAt(i) != '"') return false; //'='之后必须是双引号
                i++;
                while(i < str.length() && str.charAt(i) != '"') i++; //寻找下一个双引号
                if(i >= str.length()) return false;
                if(!hasBlank) return false; //属性之前没有空格，语法错误
            }
            hasBlank = false;
            hasAtt = true;
            i++;
        }
        if(type == 1 && hasAtt) return false; //结束标签不能有属性
        return true;
    }
}