计算机程序设计员题库
========================================

1. 在C语言中执行 int a=5; int b=a++ + ++a; 后，b的值是
  A. 11
  B. 12
  C. 13
  D. 10
  答案：B
  解析：知识点是自增运算符与序列点。a++先取5再加1使a=6，随后++a使a=7并取7，故b=5+7=12。选项11错在把两次自增都当成后置；选项13错在把第一次也当成前置；选项10错在把两次自增都当成前置后取值顺序颠倒。

2. 在Java中，以下关于String与StringBuilder的说法正确的是
  A. String对象内容不可变，StringBuilder内容可变
  B. String和StringBuilder内容都不可变
  C. String内容可变，StringBuilder内容不可变
  D. String和StringBuilder内容都可变
  答案：A
  解析：知识点是Java字符串可变性。String内部字符数组被final修饰且不暴露修改方法，每次拼接产生新对象；StringBuilder维护可扩容字符数组，append直接修改自身。选项2、3、4均把两者可变性关系说反或混为一谈。

3. 关于数据库事务隔离级别，能避免脏读但允许不可重复读的是
  A. 读未提交
  B. 读已提交
  C. 可重复读
  D. 串行化
  答案：B
  解析：知识点是隔离级别与并发异常对应关系。读已提交保证只能读到已提交数据，避免脏读，但同一事务两次读同一行可能因他人提交而不同。读未提交允许脏读；可重复读进一步避免不可重复读；串行化避免幻读且并发度最低。

4. 在Git中，想把本地已提交但尚未推送的最近一次提交与工作区修改合并进上一次提交，应使用
  A. git commit --amend
  B. git revert HEAD
  C. git reset --soft HEAD~1
  D. git cherry-pick HEAD
  答案：A
  解析：知识点是Git提交修补。git commit --amend可把暂存区改动并入上一次提交并重写该提交。git revert HEAD是生成反向提交；git reset --soft HEAD~1是撤销提交但保留改动在暂存区；git cherry-pick用于挑选其他提交。

5. 某后端接口在高并发下响应变慢，日志显示大量线程阻塞在数据库连接获取上，最应优先检查的是
  A. 数据库连接池最大连接数配置
  B. 前端页面静态资源大小
  C. 服务器CPU主频
  D. 客户端浏览器版本
  答案：A
  解析：情境案例考资源瓶颈定位。线程阻塞在获取连接，说明连接池上限或连接泄漏是直接原因。前端资源大小、CPU主频、浏览器版本与该阻塞现象无直接因果关系。

6. 关于进程与线程，下列描述正确的有
  A. 同一进程内线程共享该进程的地址空间
  B. 线程切换通常比进程切换开销小
  C. 进程是资源分配的基本单位
  D. 一个线程崩溃必然不影响同进程其他线程
  E. 每个线程拥有独立的文件描述符表
  答案：A、B、C
  解析：知识点是进程与线程区别。线程共享进程地址空间，切换开销小，进程是资源分配单位，故前三项正确。线程崩溃可能拖垮整个进程，并非必然不影响；文件描述符表属于进程级，线程共享而非各自独立。

7. 在 C 语言中，执行语句 int a = 5; printf("%d", a++ + ++a); 后输出的结果是
  A. 12
  B. 11
  C. 10
  D. 13
  答案：A
  解析：知识点是自增运算符与序列点。a++ 先取值 5，a 变为 6；++a 使 a 变为 7 再取值 7，两者相加为 12。选 11 者误以为 a++ 后即参与运算且 ++a 不改变前值；选 10 者把两处都按原值 5 计算；选 13 者把 a++ 误当作先加再取值。

8. 对单链表进行头插法建表时，若头指针为 head，新结点指针为 p，正确的插入语句序列是
  A. p->next = head; head = p;
  B. head->next = p; p->next = NULL;
  C. p->next = head->next; head->next = p;
  D. head = p; p->next = head;
  答案：A
  解析：知识点是单链表头插法。先让新结点指向原首结点，再更新头指针，顺序不能颠倒。第二项是尾插到空表的写法；第三项是带头结点链表的头插；第四项先改 head 会丢失原链表。

9. 在 Java 中，关于 String 与 StringBuilder 拼接大量字符串的性能差异，下列说法正确的是
  A. StringBuilder 在循环中拼接通常更省内存与时间
  B. String 在循环中拼接会被编译器自动优化为 StringBuilder
  C. String 的每次拼接都会复用原对象缓冲区
  D. StringBuilder 线程安全因此更适合多线程拼接
  答案：A
  解析：知识点是字符串可变性。String 不可变，循环拼接产生大量临时对象；StringBuilder 可变，追加效率高。第二项只在简单表达式拼接时可能优化，循环中不成立；第三项与不可变性矛盾；第四项 StringBuilder 非线程安全，线程安全的是 StringBuffer。

10. 对数组 [3,1,4,1,5] 执行一趟冒泡排序（从头到尾比较相邻元素并交换逆序对）后，数组变为
  A. 1,3,1,4,5
  B. 1,1,3,4,5
  C. 3,1,4,1,5
  D. 1,3,4,1,5
  答案：A
  解析：知识点是冒泡排序单趟过程。3 与 1 交换得 1,3,4,1,5；3 与 4 不换；4 与 1 交换得 1,3,1,4,5；4 与 5 不换。第二项是完全排序结果；第三项未发生任何交换；第四项中间交换过程有误。

11. 在 Git 中，已修改工作区文件但尚未暂存，此时执行 git checkout -- <file> 的效果是
  A. 用暂存区内容覆盖工作区该文件
  B. 删除该文件的所有提交历史
  C. 把该文件从暂存区移除
  D. 创建该文件的新分支
  答案：A
  解析：知识点是 Git 工作区与暂存区关系。checkout -- 会用暂存区版本覆盖工作区修改。删除提交历史是 reset 或 rebase 等操作；从暂存区移除用 git restore --staged；创建分支用 git branch。

12. 在关系数据库中，若表 A 的外键引用表 B 的主键，向表 A 插入一条外键值在表 B 中不存在的记录，数据库通常会
  A. 拒绝插入并报外键约束错误
  B. 自动在表 B 中补插一条对应记录
  C. 把该外键值置为 NULL 后插入
  D. 把该记录插入表 B 再插入表 A
  答案：A
  解析：知识点是外键约束。外键值必须存在于被引用表，否则违反参照完整性而拒绝。自动补插不会发生；置 NULL 只在允许空且未提供值时可能；跨表自动插入不是默认行为。

13. 关于 HTTP/1.1 的持久连接与 HTTP/2 的多路复用，下列描述正确的是
  A. HTTP/2 可在同一连接上并行交错多个请求响应
  B. HTTP/1.1 持久连接也支持请求响应交错发送
  C. HTTP/2 多路复用要求每个请求单独建立 TCP 连接
  D. HTTP/1.1 默认关闭持久连接
  答案：A
  解析：知识点是 HTTP 版本特性。HTTP/2 帧机制支持同一连接多路复用。HTTP/1.1 持久连接仍需按序响应；HTTP/2 多路复用正是为减少连接数；HTTP/1.1 默认开启持久连接。

14. 在 Java 中，以下关于 String 与 StringBuilder 拼接大量字符串时的说法，正确的是哪一项？
  A. String 每次拼接都会创建新对象，循环中应优先改用 StringBuilder
  B. StringBuilder 是不可变对象，拼接时会隐式创建新的 StringBuilder
  C. String 拼接在编译期会被全部优化为 StringBuilder，因此循环中无差异
  D. StringBuilder 线程安全，因此多线程拼接时无需额外同步
  答案：A
  解析：知识点：String 不可变与 StringBuilder 可变。String 每次 '+' 或 concat 都会产生新对象；StringBuilder 内部维护可变字符数组，适合循环拼接。B 错，StringBuilder 是可变对象；C 错，循环中的字符串拼接通常不会被完全优化，仍会反复创建对象；D 错，StringBuilder 不是线程安全，多线程需用 StringBuffer 或加锁。

15. 关于 Python 中列表推导式 [x*2 for x in range(5) if x%2==0] 的求值结果，下列哪一项正确？
  A. [0, 4, 8]
  B. [0, 2, 4]
  C. [2, 4, 6]
  D. [0, 4]
  答案：A
  解析：知识点：列表推导式的过滤与映射顺序。range(5) 为 0~4，x%2==0 保留 0、2、4，再乘 2 得 0、4、8。B 错，未执行乘 2；C 错，保留了奇数且映射错误；D 错，漏掉 x=4 的情况。

16. 在 C 语言中，执行 int a[5]; int *p = a; 后，表达式 *(p+3) 与下列哪一项等价？
  A. a[3]
  B. a[4]
  C. *(a+4)
  D. p[4]
  答案：A
  解析：知识点：指针算术与数组下标。p 指向 a[0]，p+3 指向 a[3]，解引用即 a[3]。B 错，a[4] 对应 p+4；C 错，a+4 指向 a[4]；D 错，p[4] 等价 *(p+4)。

17. 关于 HTTP 状态码 301 与 302 的区别，下列哪一项描述正确？
  A. 301 表示永久重定向，302 表示临时重定向
  B. 301 表示临时重定向，302 表示永久重定向
  C. 301 用于客户端错误，302 用于服务端错误
  D. 301 用于缓存命中，302 用于缓存未命中
  答案：A
  解析：知识点：HTTP 重定向状态码语义。301 Moved Permanently 为永久重定向，302 Found 为临时重定向。B 错，两者语义颠倒；C 错，3xx 是重定向，4xx/5xx 才是错误；D 错，与缓存命中无关。

18. 在 JavaScript 中，关于 == 与 === 的比较行为，下列哪一项正确？
  A. == 会进行类型转换后比较，=== 要求类型与值都相同
  B. == 要求类型相同，=== 会进行类型转换
  C. 两者都进行类型转换，=== 额外比较引用地址
  D. === 仅用于对象比较，== 仅用于基本类型比较
  答案：A
  解析：知识点：JS 宽松相等与严格相等。== 触发隐式类型转换，=== 不做转换，类型不同直接为 false。B 错，二者语义颠倒；C 错，=== 不比较引用地址而比较值与类型；D 错，二者均可用于对象与基本类型。

19. 在后端接口设计中，为防止 SQL 注入，下列哪种做法最有效？
  A. 使用参数化查询并绑定用户输入
  B. 对用户输入中的单引号做删除处理
  C. 将 SQL 语句拼接后统一转义再执行
  D. 限制数据库账号为只读权限后直接拼接
  答案：A
  解析：知识点：SQL 注入防御。参数化查询将 SQL 结构与数据分离，是根本手段。B 错，删除单引号会破坏数据且可被绕过；C 错，手工转义易遗漏且不等价于参数化；D 错，只读权限不能阻止注入查询，只能降低部分后果。

20. 在 Python 中，关于可变默认参数 def f(x, lst=[]) 的行为，下列哪一项正确？
  A. 默认列表在函数定义时创建一次，多次调用会共享同一对象
  B. 默认列表在每次调用时重新创建，调用间互不影响
  C. 默认列表在首次调用时创建，之后每次调用重新赋值
  D. 默认列表在函数返回时被销毁，下次调用重新创建
  答案：A
  解析：知识点：Python 默认参数的求值时机。默认值在 def 执行时求值一次，可变对象会被所有调用共享。B 错，默认值不在每次调用时重建；C 错，不存在首次调用才创建；D 错，默认对象生命周期与函数对象绑定。

21. 某前端页面点击按钮后需向后端提交表单并局部刷新结果，下列实现思路中最合理的是哪一项？
  A. 监听按钮点击，使用 fetch 发送请求并将返回数据渲染到目标容器
  B. 监听按钮点击，直接修改 window.location 跳转到接口地址
  C. 监听按钮点击，用 form 的默认提交并让后端返回整页 HTML
  D. 监听按钮点击，使用 setTimeout 轮询数据库直到结果出现
  答案：A
  解析：知识点：AJAX 局部刷新。fetch 异步请求并局部更新 DOM 是标准做法。B 错，整页跳转会丢失当前页面状态；C 错，默认提交导致整页刷新；D 错，轮询数据库既低效又引入不必要延迟。

22. 某服务上线后出现内存持续增长，日志显示缓存对象只增不减，下列排查与处置中最恰当的是哪一项？
  A. 检查缓存是否设置过期或淘汰策略，并补充容量上限与过期时间
  B. 立即重启服务并观察，确认不再增长后关闭监控告警
  C. 将缓存容量调大以避免频繁淘汰，再观察内存曲线
  D. 把缓存改为每次请求全量重建，避免复用旧对象
  答案：A
  解析：知识点：内存泄漏与缓存策略排查。缓存无淘汰会导致对象堆积，应补 TTL 与容量上限。B 错，重启掩盖问题且关闭告警危险；C 错，调大容量会加剧增长；D 错，全量重建会带来性能问题，且未解决泄漏根因。

23. 在C语言中执行语句 int a = 10; printf("%d", a++ + ++a); 时，若编译器严格按从左到右求值，输出结果是
  A. 22
  B. 23
  C. 21
  D. 24
  答案：A
  解析：知识点是自增运算符与序列点。a++先取值10再自增，此时a为11；++a先自增到12再取值12；10+12=22。选项23是把a++当成11参与运算；选项21是把两次自增效果重复计算；选项24是把a++按12、++a按12相加。

24. Python 中对列表 lst = [3,1,2] 执行 lst.sort(reverse=True) 后，再执行 lst.append(0) 与 lst.insert(1,9)，最终列表是
  A. [3, 9, 2, 1, 0]
  B. [9, 3, 2, 1, 0]
  C. [3, 2, 1, 0, 9]
  D. [3, 2, 9, 1, 0]
  答案：A
  解析：知识点是列表排序与插入位置。排序后为[3,2,1]，append(0)得[3,2,1,0]，insert(1,9)在下标1处插入得[3,9,2,1,0]。选项B把9插到开头；选项C把0插到末尾前；选项D把9插到2之后。

25. 在 MySQL 中，对已建表 users 增加一个允许为空且无默认值的列 age，应使用的语句是
  A. ALTER TABLE users ADD COLUMN age INT NULL
  B. ALTER TABLE users MODIFY age INT NULL
  C. UPDATE TABLE users ADD age INT NULL
  D. ALTER TABLE users INSERT age INT NULL
  答案：A
  解析：知识点是DDL中ALTER TABLE的列操作。增加新列用ADD COLUMN。选项B的MODIFY用于修改已存在列定义；选项C的UPDATE用于修改数据；选项D的INSERT不是ALTER TABLE子句。

26. HTTP 状态码 302 与 301 的核心区别是
  A. 302 是临时重定向，301 是永久重定向
  B. 302 表示资源未找到，301 表示资源已删除
  C. 302 用于 HTTPS，301 用于 HTTP
  D. 302 由客户端生成，301 由服务器生成
  答案：A
  解析：知识点是HTTP重定向语义。301表示资源永久迁移，客户端和搜索引擎可更新链接；302表示临时迁移。选项B混淆404与301；选项C与协议无关；选项D说反了，两者都由服务器返回。

27. 进程从运行态因为等待I/O完成而进入的典型状态是
  A. 阻塞态
  B. 就绪态
  C. 终止态
  D. 新建态
  答案：A
  解析：知识点是进程状态转换。运行中进程发起I/O后无法继续执行，进入阻塞态等待事件。选项B就绪态是等待CPU调度；选项C终止态是进程结束；选项D新建态是创建阶段。

28. TCP 三次握手中，客户端收到服务器返回的 SYN+ACK 后应发送的报文是
  A. ACK
  B. SYN
  C. FIN
  D. RST
  答案：A
  解析：知识点是TCP连接建立。第三次握手客户端发送ACK确认服务器序号。选项SYN用于发起连接；选项FIN用于关闭连接；选项RST用于异常重置连接。

29. 某后端接口上线后偶发超时，日志显示数据库连接池等待时间持续升高，而慢查询日志无异常记录，最应优先排查的是
  A. 连接池最大连接数配置与连接归还逻辑
  B. 数据库磁盘剩余空间是否不足
  C. 前端页面请求并发数是否过大
  D. 服务器CPU主频是否偏低
  答案：A
  解析：知识点是连接池瓶颈定位。等待时间升高且无慢查询，通常指向连接数不足或连接未及时归还。选项B无慢查询且偶发，磁盘问题概率低；选项C前端并发最终也通过连接池体现，应先查池配置；选项D与连接等待无直接因果。

30. Python 中对列表 lst 执行 lst[1:4] 操作，返回结果包含的元素个数是
  A. 2 个
  B. 3 个
  C. 4 个
  D. 不确定
  答案：B
  解析：知识点：Python 切片左闭右开。lst[1:4] 取下标 1、2、3，共 3 个元素。A 项误把右边界当包含，C 项误把起点下标也算入长度，D 项错在切片长度由下标差决定，与元素内容无关。

31. 在 MySQL 中，对已有数据的表执行 ALTER TABLE 添加一个 NOT NULL 且无默认值的列，若表中已有记录，通常结果是
  A. 自动为旧记录填 0 或空串
  B. 旧记录该列被置为 NULL
  C. 语句报错或需先给默认值
  D. 旧记录被删除后重建表
  答案：C
  解析：知识点：MySQL 加非空无默认值列的行为。严格模式下会报错，需指定默认值或允许 NULL。A 项把严格模式下的隐式转换当默认行为；B 项与 NOT NULL 约束矛盾；D 项不会删除数据，属于误传。

32. JavaScript 中使用 const 声明一个对象后，仍可修改该对象的属性，原因是
  A. const 只禁止重新赋值变量绑定
  B. const 对对象属性也生效但被引擎忽略
  C. 对象属性默认可变是历史遗留缺陷
  D. const 实际等同于 let
  答案：A
  解析：知识点：const 的语义边界。const 锁定的是变量与值的绑定，不冻结对象内部结构。B 项把引擎行为说成忽略约束；C 项把规范设计说成缺陷；D 项混淆 const 与 let 的重新赋值差异。

33. 对单链表进行头插法建表，若依次插入 1、2、3，则最终链表中从头到尾的顺序是
  A. 1、2、3
  B. 3、2、1
  C. 2、1、3
  D. 3、1、2
  答案：B
  解析：知识点：头插法建链表的顺序特性。每次新结点插在头部，最后插入的 3 在最前。A 项是尾插法结果；C、D 项不符合任何单一插入策略的稳定结果。

34. 在 Git 中，已提交但尚未推送的最近一次提交信息写错，最合适的修正命令是
  A. git commit --amend
  B. git reset --hard HEAD~1
  C. git revert HEAD
  D. git checkout HEAD~1
  答案：A
  解析：知识点：Git 提交信息修正。--amend 可修改最近一次提交。B 项会丢弃提交内容；C 项生成反向提交而非改信息；D 项切换工作区，不修改提交历史。

35. Java 中 `String s = "a" + 1 + 2;` 与 `String t = 1 + 2 + "a";` 执行后 s 和 t 的值分别是
  A. "a12" 和 "3a"
  B. "a3" 和 "3a"
  C. "a12" 和 "12a"
  D. "a3" 和 "12a"
  答案：A
  解析：知识点是字符串拼接与左结合运算顺序。s 中 "a" 先参与拼接得 "a1" 再拼 2 得 "a12"；t 中 1+2 先做整数加法得 3 再与 "a" 拼接得 "3a"。"a3" 忽略了拼接后 2 仍按字符串处理；"12a" 误认为前两个整数先拼接；"a3" 与 "12a" 组合同时犯两处错误。

36. JavaScript 中使用 `let` 在 for 循环体内声明的变量，其作用域范围是
  A. 该循环体所在的块级作用域
  B. 声明所在的整个函数
  C. 包含该循环的整个文件
  D. 仅在循环条件判断时可见
  答案：A
  解析：知识点是 let 的块级作用域。let 声明的变量仅在其所在花括号块内可见。选项二描述的是 var 的函数作用域；选项三描述的是全局或模块作用域；选项四错误地把可见范围限制在条件表达式中。

37. HTTP 状态码 301 与 302 在重定向语义上的关键差异是
  A. 301 表示永久重定向，302 表示临时重定向
  B. 301 表示临时重定向，302 表示永久重定向
  C. 301 用于 HTTPS，302 用于 HTTP
  D. 301 用于 GET，302 用于 POST
  答案：A
  解析：知识点是 HTTP 重定向状态码的语义区别。301 为永久移动，客户端和搜索引擎可缓存并更新引用；302 为临时移动，后续请求仍应使用原地址。选项二把两者语义对调；选项三混淆了协议与状态码；选项四错误地把重定向与请求方法绑定。

38. 在 Git 中，执行 `git reset --soft HEAD~1` 与 `git reset --hard HEAD~1` 的核心区别是
  A. 前者保留暂存区和工作区改动，后者丢弃这些改动
  B. 前者丢弃暂存区和工作区改动，后者保留这些改动
  C. 前者只移动分支指针不改变提交历史，后者会删除提交对象
  D. 前者用于远程分支，后者用于本地分支
  答案：A
  解析：知识点是 git reset 三种模式对工作区和暂存区的影响。--soft 仅回退提交并保留暂存区与工作区内容；--hard 同时重置暂存区和工作区，改动丢失。选项二把两者对调；选项三错在两者都会移动分支指针且都不会立即删除提交对象；选项四错在两种模式都可用于本地分支。

39. 若对一棵二叉搜索树进行中序遍历，得到的序列特点是
  A. 按关键字递增有序排列
  B. 按关键字递减有序排列
  C. 与插入顺序完全一致
  D. 按树的层序排列
  答案：A
  解析：知识点是二叉搜索树的中序遍历性质。中序遍历按左-根-右顺序访问，得到递增有序序列。选项二是递减序列，对应右-根-左的逆中序；选项三描述的是插入顺序而非遍历结果；选项四描述的是层序遍历。

40. 某后端服务在高峰期频繁出现数据库连接池耗尽，日志显示大量请求阻塞在获取连接阶段。此时最应优先排查的环节是
  A. 连接是否在使用后正确归还以及是否存在长事务占用
  B. 服务器 CPU 主频是否低于同型号平均水平
  C. 前端页面是否启用了浏览器缓存
  D. 数据库表的字段命名是否使用下划线风格
  答案：A
  解析：知识点是连接池耗尽的常见根因。连接未归还或长事务长期占用连接会直接导致池耗尽。选项二与连接获取阻塞无直接因果；选项三只影响静态资源加载；选项四属于命名规范，不影响连接持有时间。

41. 在 C 语言中执行语句 int a = 5; printf("%d", a++ + ++a); 时，若编译器遵循先计算右操作数再计算左操作数的求值顺序，则输出结果是
  A. 11
  B. 12
  C. 13
  D. 10
  答案：B
  解析：知识点为自增运算符与表达式中操作数求值顺序。若先算右操作数 ++a，a 变为 6，右操作数为 6；再算左操作数 a++，左操作数取当前值 6，然后 a 变为 7，因此 6+6=12，选 12。选项 11 是假设先算左操作数再算右操作数的结果；选项 13 是把 a++ 取值为 5、++a 为 8 的错误推算；选项 10 是忽略 ++a 对 a 的修改直接相加。

42. 在 Java 中，父类引用指向子类对象并调用一个父类中已定义、子类中已重写的非静态方法时，实际执行的是子类方法，这一现象体现的机制是
  A. 编译期重载解析
  B. 运行期动态绑定
  C. 静态方法隐藏
  D. 构造器链式调用
  答案：B
  解析：知识点为面向对象多态与动态绑定。父类引用调用被重写的方法时，JVM 在运行期根据对象实际类型选择子类方法，属于动态绑定。选项“编译期重载解析”描述的是重载在编译期按参数静态类型选择；选项“静态方法隐藏”适用于 static 方法，不参与多态；选项“构造器链式调用”描述的是子类构造器调用父类构造器的过程，与方法重写无关。

43. 在 Python 中，表达式 [x * 2 for x in range(3) if x % 2 == 0] 的求值结果是
  A. [0, 4]
  B. [0, 2]
  C. [2, 4]
  D. [0, 2, 4]
  答案：A
  解析：知识点为列表推导式的过滤条件与映射顺序。range(3) 产生 0、1、2，先筛选 x%2==0 得到 0 和 2，再分别乘 2 得到 0 和 4，结果为 [0, 4]。选项 [0, 2] 是筛选后未乘 2；选项 [2, 4] 是把 0 排除在偶数之外；选项 [0, 2, 4] 是未过滤直接对 range(3) 乘 2 的错误结果。

44. 在 MySQL 中，对 InnoDB 表执行 SELECT ... FOR UPDATE 时，若查询条件命中主键索引上的单行记录，该语句主要施加的锁是
  A. 表级共享锁
  B. 该行的排他行锁
  C. 该行的共享行锁
  D. 间隙锁且不含行锁
  答案：B
  解析：知识点为 InnoDB 行锁与 SELECT ... FOR UPDATE 语义。命中主键唯一记录时，FOR UPDATE 对该行加排他行锁，阻止其它事务修改或加排他锁。选项“表级共享锁”会阻塞写但允许并发读，不是 FOR UPDATE 的主要效果；选项“该行的共享行锁”是 LOCK IN SHARE MODE 的效果；选项“间隙锁且不含行锁”描述的是范围查询防止幻读时的部分加锁方式，单行主键命中不以间隙锁为主。

45. 在 TCP 连接中，当接收方收到一个序号超出当前接收窗口、且不能立即放入乱序缓冲区的报文段时，按 RFC 规范应发送的响应是
  A. 重复确认已收到的最后一个有序字节
  B. 发送 RST 复位该连接
  C. 把接收窗口调整为 0 并静默丢弃
  D. 回退 N 步重传全部未确认数据
  答案：A
  解析：知识点为 TCP 接收窗口与重复 ACK 机制。收到超出窗口的报文段时，接收方应丢弃该段并重复确认最后一个按序到达的字节，触发发送方快速重传。选项“发送 RST”用于连接严重错误或端口不可达等场景，不用于普通窗口外数据；选项“把接收窗口调整为 0”是接收缓冲区满时的流控行为，与此不同；选项“回退 N 步重传”是发送方在超时后的策略，不是接收方响应。

46. 在 Git 中，若本地分支 feature 已提交若干次，此时执行 git rebase main 后，feature 分支上原有提交的哈希值通常会
  A. 保持不变且历史线性
  B. 发生改变并生成新提交
  C. 被自动合并为一次提交
  D. 被移动到 main 分支之前
  答案：B
  解析：知识点为 Git rebase 的提交重写机制。rebase 把 feature 的提交依次应用到 main 的新基点上，提交内容相同但父提交改变，因此哈希值改变并生成新提交。选项“保持不变且历史线性”混淆了 merge 与 rebase；选项“被自动合并为一次提交”是 squash 或交互式 rebase 的特定操作；选项“被移动到 main 之前”描述的是分支指针位置，不是提交哈希变化。

47. 在 HTTP/1.1 中，服务器响应头包含 Cache-Control: no-store 时，客户端和中间缓存对该响应的正确处理方式是
  A. 可以缓存但每次使用前必须重新验证
  B. 不得以任何形式存储该响应
  C. 可缓存 60 秒后自动过期
  D. 仅允许私有缓存保存该响应
  答案：B
  解析：知识点为 HTTP 缓存控制指令。no-store 表示响应不得被任何缓存存储，包括客户端和中间代理。选项“可以缓存但每次使用前必须重新验证”对应 no-cache；选项“可缓存 60 秒后自动过期”对应 max-age=60；选项“仅允许私有缓存保存”对应 private，均与 no-store 语义不同。

48. 某后端服务上线后出现接口偶发超时，日志显示数据库连接池活跃连接数长期接近上限，且慢查询日志中多条 SQL 未命中索引；此时最合理的首要处置是
  A. 直接扩大连接池最大连接数并重启服务
  B. 先定位并优化未命中索引的慢查询语句
  C. 把数据库事务隔离级别降为读未提交
  D. 在应用层对所有接口统一增加重试次数
  答案：B
  解析：知识点为性能问题定位与连接池瓶颈分析。活跃连接接近上限且存在未命中索引的慢查询，说明连接被慢 SQL 长时间占用，应先优化慢查询释放连接。选项“扩大连接池并重启”只是掩盖问题，可能加重数据库负载；选项“降低隔离级别”不能解决索引缺失导致的慢查询；选项“统一增加重试”会进一步放大数据库压力。

49. 关于 JavaScript 中 let 与 var 声明变量的差异，下列描述正确的有
  A. let 声明的变量存在块级作用域，var 声明的变量属于函数作用域
  B. 在同一个块中 let 不允许重复声明同名变量，var 允许重复声明
  C. let 声明的变量在声明前访问会抛出 ReferenceError，var 声明前访问得到 undefined
  D. let 声明的变量会被提升到所在函数顶部并初始化为 undefined
  E. var 声明的变量在全局作用域下不会成为 window 对象的属性
  答案：A、B、C
  解析：知识点为 JavaScript 变量声明与作用域。let 具有块级作用域，var 具有函数作用域，故第一项正确；同一块内 let 禁止重复声明，var 可以重复声明，故第二项正确；let 存在暂时性死区，声明前访问抛 ReferenceError，var 声明前访问为 undefined，故第三项正确。第四项错误，let 虽被提升但不初始化，不会得到 undefined；第五项错误，全局 var 声明会成为 window 属性，let 不会。

50. 某后端服务用哈希表缓存用户会话，键为用户ID字符串，运行中发现偶发查询变慢；经排查是多个不同用户ID映射到同一桶位，且这些键的哈希值分布集中，下列哪些改进措施能直接缓解该问题？
  A. 在哈希函数中引入用户ID的随机盐值再取模桶数
  B. 将桶数从固定质数改为2的幂并用位运算取模
  C. 对哈希冲突的桶改用红黑树存储长链表
  D. 把用户ID字符串先转为整数再直接作为桶下标
  E. 在每次查询前对缓存整体做一次全量重哈希
  答案：A、C
  解析：知识点为哈希冲突与哈希表性能优化。引入随机盐值可打散集中分布的哈希值，减少同桶聚集；冲突桶转红黑树可将长链表的最坏查询从O(n)降为O(log n)，两者都能直接缓解变慢。改为2的幂并用位运算取模在哈希值低位分布不佳时反而更容易聚集；把字符串转整数直接作桶下标会因整数范围远大于桶数导致越界或大量冲突；全量重哈希不改变哈希分布特性，且开销大、不解决根因。

51. 在 Python 中执行表达式 len("程序设计") 的结果是
  A. 4
  B. 5
  C. 6
  D. 8
  答案：A
  解析：知识点：Python 中 len() 对字符串返回字符个数，中文字符按一个字符计。"程序设计"共 4 个汉字，故结果为 4。选项 5、6 是把常见词长记混；选项 8 是误按 UTF-8 字节数（每汉字 3 字节）计算。

52. C 语言中，对于数组 int a[5]，表达式 *(a+2) 与下列哪个写法等价
  A. a[2]
  B. a[1]
  C. a[3]
  D. &a[2]
  答案：A
  解析：知识点：数组名在表达式中退化为首元素指针，*(a+i) 等价于 a[i]。故 *(a+2) 等价 a[2]。选项 a[1]、a[3] 是下标偏移记错；&a[2] 取的是地址而非元素值。

53. 时间复杂度为 O(n log n) 的排序算法是
  A. 归并排序
  B. 冒泡排序
  C. 插入排序
  D. 选择排序
  答案：A
  解析：知识点：常见排序算法平均时间复杂度。归并排序稳定为 O(n log n)。冒泡、插入、选择排序平均均为 O(n²)，属于易混的基础算法复杂度。

54. HTTP 状态码 301 与 302 的核心区别是
  A. 301 表示资源永久移动，302 表示临时移动
  B. 301 表示请求成功，302 表示重定向
  C. 301 表示客户端错误，302 表示服务端错误
  D. 301 表示缓存命中，302 表示缓存未命中
  答案：A
  解析：知识点：HTTP 重定向状态码语义。301 为永久重定向，302 为临时重定向，影响浏览器缓存与 SEO。选项把成功码 200、客户端错误 4xx、服务端错误 5xx、缓存机制混入，属于相邻概念误植。

55. 在关系型数据库中，能保证一个事务的修改在提交前对其他事务不可见的特性是
  A. 隔离性
  B. 原子性
  C. 一致性
  D. 持久性
  答案：A
  解析：知识点：事务 ACID 特性。隔离性指并发事务之间互不干扰，未提交的修改对其他事务不可见。原子性指要么全做要么全不做；一致性指数据约束不被破坏；持久性指提交后不丢失。

56. Git 中把本地分支 feature 的提交变基到 main 分支最新提交之上的命令是
  A. git rebase main feature
  B. git merge main feature
  C. git checkout main feature
  D. git reset main feature
  答案：A
  解析：知识点：Git rebase 用法。git rebase main feature 表示把 feature 分支的提交移到 main 之上。merge 是合并产生合并提交；checkout 是切换分支；reset 是移动指针，语义不同。

57. 某后端接口返回列表数据时偶发乱序，排查发现代码先对结果集做了分页再排序，正确的修复环节是
  A. 先对完整结果集排序，再执行分页截取
  B. 把排序字段加入分页参数中一并传递
  C. 在分页之后补一次去重操作
  D. 将分页大小临时调大以避免乱序
  答案：A
  解析：情境案例：分页与排序的先后顺序影响结果正确性。正确做法是先排序再分页，保证每页内部有序。把排序字段塞进分页参数不解决顺序问题；分页后去重与顺序无关；调大分页大小只是掩盖现象。

58. 程序运行中抛出空指针异常，日志显示调用链最深处为对象方法调用，优先排查的方向是
  A. 调用该方法前对象引用是否已被赋值
  B. 该方法的返回类型是否声明错误
  C. 方法的访问修饰符是否为 public
  D. 方法参数是否使用了可变参数
  答案：A
  解析：情境案例：空指针异常通常源于引用为 null。优先检查调用前引用是否已正确赋值。返回类型、访问修饰符、可变参数与空指针成因无关，属于相邻但错误的排查方向。

59. 关于栈和队列的特性，下列描述正确的有
  A. 栈遵循后进先出原则
  B. 队列遵循先进先出原则
  C. 栈只能在栈顶进行插入和删除
  D. 队列只能在队尾进行插入和删除
  E. 栈和队列都支持随机访问任意元素
  答案：A、B、C
  解析：知识点：栈与队列的基本特性。栈后进先出，插入删除都在栈顶；队列先进先出，插入在队尾。选项称队列只能在队尾删除错误，删除应在队头；选项称两者都支持随机访问错误，二者都是受限的线性表。

60. 用链表实现栈时，若只在链表头部进行插入和删除，入栈和出栈操作的时间复杂度分别是
  A. O(1) 和 O(1)
  B. O(1) 和 O(n)
  C. O(n) 和 O(1)
  D. O(n) 和 O(n)
  答案：A
  解析：知识点：链式栈的操作特性。在链表头部插入和删除都只需修改头指针和相邻指针，无需遍历，因此均为 O(1)。选项B误以为出栈需要遍历找前驱；选项C误以为入栈需要遍历到尾部；选项D把两种操作都当作需要遍历。

61. 关于冒泡排序的稳定性，下列判断正确的是
  A. 当相邻元素相等时不交换，冒泡排序是稳定的
  B. 冒泡排序一定不稳定，因为会交换相邻元素
  C. 冒泡排序的稳定性取决于数组初始顺序
  D. 冒泡排序稳定，但前提是每轮必须交换相等元素
  答案：A
  解析：知识点：排序稳定性。稳定性指相等元素的相对次序是否保持，冒泡排序在相等时不交换即可保持稳定。选项B误以为交换相邻元素必然破坏稳定性；选项C把稳定性与初始顺序混为一谈；选项D的做法反而会破坏相等元素的相对次序。

62. 在 HTTP 请求中，前端向服务器提交表单数据并希望刷新后不重复提交，较合适的做法是
  A. 提交后由服务器返回 303 重定向到结果页
  B. 提交后由服务器直接返回 200 显示结果
  C. 提交后由服务器返回 302 且浏览器自动重发 POST
  D. 提交后由服务器返回 307 并保留原 POST 方法
  答案：A
  解析：知识点：HTTP 重定向状态码语义。303 会把后续请求改为 GET，避免刷新重复提交 POST。选项B直接返回结果页，刷新会触发重复提交提示；选项C的 302 在部分浏览器中可能仍以原方法重发；选项D的 307 明确保留原方法，会加重重复提交。

63. 用递归实现斐波那契数列时，若不加记忆化，n 稍大就会非常慢，主要原因是
  A. 同一子问题被重复计算了多次
  B. 递归调用栈太浅导致溢出
  C. 每次递归都重新分配数组
  D. 递归函数无法使用循环
  答案：A
  解析：知识点：递归与重叠子问题。朴素递归计算 fib(n) 会反复求解相同的 fib(k)，导致指数级时间。选项B说栈太浅与事实相反；选项C与朴素递归的实现方式不符；选项D与递归能否使用循环无关。

64. 在 Git 中，若想把本地分支 feature 的提交整理后合并到 main 并保持线性历史，较合适的操作是
  A. 切到 main 后执行 git rebase feature 再快进合并
  B. 切到 main 后执行 git merge --no-ff feature
  C. 切到 feature 后执行 git merge main
  D. 在 main 上执行 git cherry-pick feature 的全部提交
  答案：A
  解析：知识点：Git 变基与合并策略。rebase 可把 feature 的提交移到 main 最新提交之后，形成线性历史。选项B会引入合并提交，不是线性历史；选项C方向反了，是把 main 合进 feature；选项D只复制提交，不整理 feature 分支且可能产生重复提交。

65. 关于 TCP 三次握手，下列描述正确的是
  A. 第三次握手后服务器才进入 ESTABLISHED 状态
  B. 第二次握手后客户端就进入 ESTABLISHED 状态
  C. 第一次握手客户端发送的是 ACK 报文
  D. 三次握手的目的是确认双方 MSS 大小
  答案：A
  解析：知识点：TCP 连接建立过程。服务器收到第三次握手的 ACK 后才进入 ESTABLISHED。选项B错误，客户端在收到第二次握手后才进入 ESTABLISHED；选项C错误，第一次握手发送的是 SYN；选项D把三次握手的目的与 MSS 协商混淆。

66. 在 SQL 中，若表 orders 有字段 user_id 且需要查询每个用户订单数并只显示订单数大于 3 的用户，正确写法是
  A. SELECT user_id, COUNT(*) FROM orders GROUP BY user_id HAVING COUNT(*) > 3
  B. SELECT user_id, COUNT(*) FROM orders WHERE COUNT(*) > 3 GROUP BY user_id
  C. SELECT user_id, COUNT(*) FROM orders GROUP BY user_id WHERE COUNT(*) > 3
  D. SELECT user_id, COUNT(*) FROM orders HAVING COUNT(*) > 3
  答案：A
  解析：知识点：GROUP BY 与 HAVING。聚合后的过滤要用 HAVING，且需配合 GROUP BY。选项B把聚合条件写进 WHERE，执行顺序不允许；选项C把 WHERE 放在 GROUP BY 之后，语法位置错误；选项D缺少 GROUP BY，无法按用户分组。

67. 某后端接口偶发返回旧数据，排查发现读请求走了从库而写请求走主库，最可能的原因是
  A. 主从复制存在延迟，读请求读到了尚未同步的从库
  B. 从库磁盘比主库慢导致读超时
  C. 写请求没有加事务导致数据丢失
  D. 接口没有设置缓存导致读到旧数据
  答案：A
  解析：知识点：读写分离与复制延迟。写主读从时，从库同步有延迟，短时间内读会拿到旧值。选项B把延迟原因归为磁盘速度，不能解释偶发旧数据；选项C与读写分离场景不符；选项D把问题归为缓存，但题干未提缓存。

68. 在C语言中执行语句 int a = 5; printf("%d", a++ + ++a); 后，若编译器遵循标准未定义行为之外的常见求值顺序（先取a++得5，a变为6，再算++a得7），则输出结果是
  A. 12
  B. 11
  C. 13
  D. 10
  答案：A
  解析：知识点为自增运算符与序列点。标准中同一表达式对同一变量多次修改属未定义行为，但常见实现按从左到右求值：a++返回5，a变6，++a使a变7并返回7，5+7=12。选项11是把a++当成6计算；选项13是把++a当成6后又多加；选项10是漏算一次自增。

69. 下列关于TCP三次握手中第二次握手报文特征的说法，正确的是
  A. SYN=1且ACK=1，确认号为客户端初始序号加1
  B. SYN=1且ACK=0，确认号为客户端初始序号加1
  C. SYN=0且ACK=1，确认号为客户端初始序号加1
  D. SYN=1且ACK=1，确认号为服务器初始序号加1
  答案：A
  解析：知识点为TCP连接建立。第二次握手服务器同时置SYN和ACK，确认号是对客户端SYN序号的确认即客户端ISN+1。选项SYN=1且ACK=0漏掉确认标志；SYN=0且ACK=1退化成普通确认；确认号为服务器ISN+1混淆了确认对象。

70. 关于进程与线程的区别，下列说法正确的是
  A. 同一进程内多个线程共享该进程的地址空间
  B. 线程拥有独立的地址空间而进程共享地址空间
  C. 进程切换开销一定小于线程切换开销
  D. 一个进程只能包含一个线程
  答案：A
  解析：知识点为进程与线程。同进程线程共享地址空间。线程独立地址空间说法反了；进程切换通常开销更大；一个进程可含多线程。

71. 在Python中，关于列表推导式 [x*2 for x in range(3)] 的结果，正确的是
  A. [0, 2, 4]
  B. [2, 4, 6]
  C. [0, 1, 2]
  D. [0, 2, 4, 6]
  答案：A
  解析：知识点为列表推导式。range(3)产生0、1、2，各乘2得0、2、4。选项含2、4、6起点错；0、1、2未乘2；多出6超出范围。

72. 在 Java 中，以下关于 String、StringBuilder 和 StringBuffer 的叙述，哪一项是正确的
  A. String 对象一旦创建其内容不可变，每次拼接都会产生新对象
  B. StringBuilder 是线程安全的，适合多线程环境下频繁拼接字符串
  C. StringBuffer 的 append 方法比 StringBuilder 更快，因为它做了缓冲
  D. String 的 + 拼接在循环中会被编译器优化为 StringBuilder 复用
  答案：A
  解析：知识点：Java 字符串类的可变性与线程安全。String 不可变，拼接产生新对象，A 正确；StringBuilder 非线程安全，B 错；StringBuffer 因加锁通常比 StringBuilder 慢，C 错；循环中的 + 拼接在多数实现中每次迭代都会新建 StringBuilder，并非复用，D 错。

73. 在 Python 中执行 d = {}; d[(1,2)] = 'a'; d[[1,2]] = 'b' 会得到什么结果
  A. 两次赋值都成功，字典有两个键
  B. 第一次成功，第二次抛出 TypeError
  C. 第一次抛出 KeyError，第二次成功
  D. 两次都抛出 TypeError，字典为空
  答案：B
  解析：知识点：字典键的可哈希性。元组 (1,2) 不可变可哈希，能作键；列表 [1,2] 可变不可哈希，作键时抛 TypeError，故 B 正确。A、C、D 对可哈希性的判断均不成立。

74. 以下关于 HTTP 状态码的叙述，哪一项符合语义
  A. 301 表示资源临时移动，客户端下次仍应请求原地址
  B. 401 表示服务器理解请求但拒绝授权，需先认证
  C. 403 表示请求的资源不存在，应重定向到首页
  D. 502 表示客户端请求语法错误，需修改请求体
  答案：B
  解析：知识点：HTTP 状态码语义。401 是未认证需先认证，B 正确；301 是永久移动，A 错；403 是禁止访问而非不存在，C 错；502 是网关收到无效响应，D 错。

75. 在前端 JavaScript 中，关于事件冒泡与捕获的顺序，以下哪项描述正确
  A. 捕获阶段从目标元素向根节点传播，冒泡阶段从根向目标传播
  B. 捕获阶段从根节点向目标元素传播，冒泡阶段从目标向根传播
  C. addEventListener 第三个参数为 true 时表示在冒泡阶段触发
  D. stopPropagation 会同时阻止捕获和冒泡但不会阻止默认行为
  答案：B
  解析：知识点：DOM 事件流。捕获从根到目标，冒泡从目标到根，B 正确；A 把两者方向说反；true 表示捕获阶段触发，C 错；stopPropagation 阻止传播但确实不阻止默认行为，表述方向对但选项文字与正确项不符，D 作为单选被排除。

76. 给定递归函数 f(n) = f(n-1) + f(n-2)，f(0)=0，f(1)=1，直接递归计算 f(6) 的过程中，f(3) 被重复计算的次数是多少
  A. 2 次
  B. 3 次
  C. 4 次
  D. 5 次
  答案：C
  解析：知识点：递归调用树与重复子问题。展开 f(6) 的调用树，f(3) 分别在 f(5) 左支、f(4) 左支、f(3) 自身、f(4) 右支等路径出现，共 4 次。选 4 次。

77. 在 SQL 中，表 t 有列 a，执行 SELECT a, COUNT(*) FROM t GROUP BY a HAVING COUNT(*) > 1 的语义是
  A. 筛选出 a 列值重复的记录并显示 a 和重复次数
  B. 筛选出 a 列值唯一的记录并显示 a 和计数 1
  C. 先对全表计数再按 a 过滤，等价于 WHERE
  D. 对 a 排序后取前两条重复记录
  答案：A
  解析：知识点：GROUP BY 与 HAVING。该语句按 a 分组，保留计数大于 1 的组，即 a 值重复的组并显示次数，A 正确；B 条件相反；C 混淆 HAVING 与 WHERE；D 与排序取前无关。

78. 在 C 语言中，以下代码片段 char *p = "hello"; p[0] = 'H'; 的运行结果是
  A. 正常执行，字符串变为 Hello
  B. 编译报错，因为字符串字面量不可修改
  C. 运行时段错误，因为试图写入只读内存
  D. 输出警告但运行时忽略修改
  答案：C
  解析：知识点：字符串字面量存储于只读区。p 指向只读区，p[0] 写入触发段错误，C 正确；A 认为可改错；B 编译器通常只给警告不报错；D 运行时不会忽略非法写入。

79. 某后端接口在压测中出现响应时间随并发升高而急剧上升、CPU 使用率却不高，最可能的原因是
  A. 线程池核心线程数设置过小导致任务排队等待
  B. 数据库连接池被占满导致请求阻塞在获取连接
  C. JVM 堆内存不足频繁触发 Full GC
  D. 网络带宽达到上限导致数据包丢失重传
  答案：B
  解析：知识点：性能问题定位。CPU 不高而响应变慢，常见于等待型瓶颈如连接池耗尽，B 最符合；A 会体现为队列但通常伴随 CPU 空闲也可能，但连接池阻塞更典型；C 会伴随 CPU 升高；D 会体现为丢包重传且带宽指标异常。

80. 线上服务突然大量抛出 NullPointerException，日志显示某对象在初始化后仍为 null，最合理的下一步排查动作是
  A. 立即重启服务以恢复可用性并观察是否复现
  B. 回滚最近一次发布并保留现场日志与堆栈
  C. 调大 JVM 内存参数避免空指针
  D. 关闭该接口的异常捕获让请求快速失败
  答案：B
  解析：知识点：线上故障处置流程。先止损并保留现场，回滚最近发布是常用手段，B 正确；A 重启会丢失现场且可能掩盖根因；C 空指针与内存无关；D 关闭捕获会扩大影响且不定位问题。

81. 关于进程与线程的区别，以下叙述正确的有哪些
  A. 进程拥有独立的地址空间，线程共享所属进程的地址空间
  B. 线程切换通常比进程切换开销小，因为不涉及地址空间切换
  C. 同一进程内的线程可以直接读写对方的栈内存
  D. 进程间通信必须通过内核提供的机制，如管道或共享内存
  E. 一个线程崩溃必然导致同进程其他线程全部立即终止
  答案：A、B、D
  解析：知识点：进程与线程模型。A、B、D 均正确；C 错，线程各自有独立栈，不能随意读写对方栈；E 错，线程崩溃可能影响进程但并非必然立即终止全部线程（取决于实现与信号处理）。

82. 在 Python 中执行表达式 3 * 1 ** 2 后，结果是多少
  A. 9
  B. 6
  C. 3
  D. 1
  答案：C
  解析：知识点是 Python 运算符优先级，** 的优先级高于 *。正确项：先算 1**2 得 1，再算 3*1 得 3。错误项 9 是把式子误读为 (3*1)**2；错误项 6 是误把 1**2 当成 1*2；错误项 1 是忽略乘法只先算了幂。

83. C 语言中，函数内定义的 static int count = 0; 每次进入该函数时 count 的初值表现是
  A. 保持上次调用结束时的值
  B. 每次重新初始化为 0
  C. 由编译器随机决定
  D. 等于上一次的返回值
  答案：A
  解析：知识点是 static 局部变量的存储期与初始化时机。正确项：static 局部变量只初始化一次，函数返回后仍保留值。错误项 每次重新初始化为 0 是普通自动变量的行为；错误项 由编译器随机决定 混淆了未初始化自动变量的不确定性；错误项 等于上一次的返回值 与变量存储无关。

84. 在 Git 中，把本地 feature 分支的提交变基到最新 main 分支之上，通常使用哪条命令
  A. git rebase main
  B. git merge main
  C. git checkout main
  D. git reset main
  答案：A
  解析：知识点是 Git 变基与合并的区别。正确项：在 feature 分支上执行 git rebase main 会把本分支提交重放到 main 最新提交之后。错误项 git merge main 产生合并提交而非变基；错误项 git checkout main 只是切换分支；错误项 git reset main 会移动当前分支指针并可能丢弃提交。

85. 关系数据库中，若表 R 已满足第三范式，则它一定满足的是
  A. 第二范式
  B. BCNF
  C. 第四范式
  D. 第五范式
  答案：A
  解析：知识点是关系数据库范式的包含关系。正确项：3NF 蕴含 2NF 和 1NF。错误项 BCNF 比 3NF 更严格，满足 3NF 不一定满足 BCNF；错误项 第四范式 和 第五范式 均比 3NF 更严格，不能由 3NF 推出。

86. 在 TCP 三次握手过程中，客户端收到服务器返回的 SYN+ACK 后，发送的报文段标志位是
  A. ACK
  B. SYN
  C. FIN
  D. RST
  答案：A
  解析：知识点是 TCP 建立连接的三次握手。正确项：第三次握手客户端发送 ACK 确认服务器序号。错误项 SYN 是第一次握手使用的标志；错误项 FIN 用于关闭连接；错误项 RST 用于异常复位连接。

87. 在 Python 中，列表推导式 [x*x for x in range(3)] 的结果是
  A. [0, 1, 4]
  B. [1, 4, 9]
  C. [0, 1, 2]
  D. [1, 2, 3]
  答案：A
  解析：知识点是 range 左闭右开与列表推导式。正确项：range(3) 产生 0、1、2，平方后为 0、1、4。错误项 [1, 4, 9] 是把 range(3) 误当成 1 到 3；错误项 [0, 1, 2] 是未做平方；错误项 [1, 2, 3] 是既改了起点又未平方。

88. 在面向对象设计中，子类重写父类方法时把访问权限由public改为private，这主要违反了哪一原则
  A. 单一职责原则
  B. 里氏替换原则
  C. 依赖倒置原则
  D. 接口隔离原则
  答案：B
  解析：里氏替换原则要求子类对象能替换父类对象且不破坏行为契约，缩小访问权限会破坏可替换性。单一职责讲类的职责划分；依赖倒置讲依赖抽象；接口隔离讲接口拆分，均不直接对应访问权限收窄。

89. Java中关于String与StringBuilder拼接大量字符串的性能差异，下列说法符合实际运行机制的是
  A. String每次拼接都会创建新对象，StringBuilder在可变字符数组上追加
  B. String拼接由编译器统一优化为StringBuilder，二者完全等价
  C. StringBuilder线程安全所以更适合高并发拼接场景
  D. String内部使用链表存储，拼接时只修改指针不复制内容
  答案：A
  解析：String不可变，每次拼接产生新对象；StringBuilder内部为可变字符数组，追加开销小。编译器的确会把简单常量拼接优化，但循环中拼接不能完全等价；StringBuilder非线程安全；String底层是字符数组不是链表。

90. 快速排序在待排序列已经基本有序且每次取首元素为基准时，最坏时间复杂度出现的根本原因是
  A. 每次划分后子问题规模接近n-1和0
  B. 基准元素恰好等于序列最大值
  C. 递归调用层数低于log n导致栈空闲
  D. 元素比较次数少于归并排序
  答案：A
  解析：取首元素为基准且序列有序时，每次划分极不平衡，一侧为n-1、另一侧为0，退化为O(n²)。基准为最大值只是极端不平衡的一种表现而非根本描述；递归层数会变深而非变浅；比较次数并非少于归并排序。

91. HTTP/1.1中启用持久连接后，若客户端发送的请求未带Connection头，服务器默认采取的行为是
  A. 关闭连接并等待下次请求
  B. 保持连接直到超时或显式关闭
  C. 立即升级为HTTP/2
  D. 每条请求重新建立TCP连接
  答案：B
  解析：HTTP/1.1默认持久连接，未带Connection头时连接保持，直到超时或收到close。关闭连接、升级HTTP/2、每请求重建连接均不符合默认行为。

92. 在关系数据库中，若表R的外键引用表S的主键，向R插入一条外键值在S中不存在的记录，数据库通常会
  A. 自动在S中插入缺失的被引用行
  B. 拒绝插入并报违反外键约束
  C. 将外键列置为NULL后插入
  D. 延迟到事务提交时再校验并通过
  答案：B
  解析：外键约束要求被引用值存在，否则拒绝插入。自动插入被引用行不是默认行为；置NULL需列允许且语义不同；延迟校验只改变校验时机，值仍不存在时依然失败。

93. Git中执行 git reset --soft HEAD~1 后，被撤销的那次提交所包含的修改所处状态是
  A. 工作区已修改，暂存区为空
  B. 暂存区已暂存，工作区不变
  C. 工作区和暂存区都被清空
  D. 修改已彻底丢失，无法恢复
  答案：B
  解析：--soft只移动HEAD指针，不改暂存区和工作区，故修改仍在暂存区。工作区已修改、暂存区为空是--mixed的效果；两者清空是--hard；修改不会丢失。

94. 关于TCP三次握手，客户端收到服务器的SYN+ACK后发送的ACK报文，其序列号应设置为
  A. 客户端初始序列号加1
  B. 服务器序列号加1
  C. 客户端初始序列号
  D. 服务器序列号
  答案：B
  解析：第三次握手的ACK确认号应为服务器序列号加1，表示确认收到SYN。客户端初始序列号加1是第二次握手可能的确认号方向；直接用两端原始序列号均不正确。

95. 在C语言中，执行 int a = 5; int b = a++ + ++a; 后，b 的值在多数常见编译器下是多少
  A. 10
  B. 11
  C. 12
  D. 13
  答案：C
  解析：知识点是自增运算符与序列点未定义行为。多数编译器先算 a++ 得5、a变6，再算 ++a 得7、a变7，相加为12；但该表达式实际属未定义行为，不同编译器可能不同。选项10忽略了两次自增对a的叠加影响；选项11只累加了一次自增；选项13把两次自增都当成前置计算。

96. 在 Java 中，父类引用指向子类对象并调用被子类重写的实例方法时，实际执行的是
  A. 父类中定义的方法
  B. 子类中重写的方法
  C. 编译时报错无法通过
  D. 取决于引用变量声明类型
  答案：B
  解析：知识点是运行时多态。实例方法调用采用动态绑定，实际执行子类重写版本。选项一混淆了静态绑定；选项三误认为父类引用不能调重写方法；选项四把绑定依据错当成引用声明类型。

97. 某后端接口在压测时响应时间随并发数上升先平稳后急剧增大，且CPU利用率接近饱和、GC日志频繁出现Full GC，最应优先排查的方向是
  A. 数据库连接池最大连接数是否过小
  B. 应用堆内存与对象创建速率是否合理
  C. 前端静态资源是否启用CDN
  D. HTTP响应头是否缺少缓存字段
  答案：B
  解析：知识点是性能瓶颈定位。CPU饱和且频繁Full GC指向堆内存不足或对象分配过快，应优先查堆与分配。连接池过小通常表现为等待连接而非CPU饱和；CDN与响应头缓存影响的是静态资源与网络层，不解释JVM内Full GC频繁。

98. 使用 Git 时，本地已提交若干次，但尚未推送到远程，此时执行 git reset --soft HEAD~1 的效果是
  A. 撤销最近一次提交并丢弃其改动
  B. 撤销最近一次提交且改动保留在暂存区
  C. 撤销最近一次提交且改动保留在工作区但不在暂存区
  D. 将最近一次提交反向应用到当前分支并生成新提交
  答案：B
  解析：知识点是 git reset 三种模式区别。--soft 只移动 HEAD，暂存区与工作区不变，故改动仍在暂存区。选项一对应 --hard；选项三对应 --mixed（默认）；选项四描述的是 git revert 的行为。

99. 在编写多线程程序时，下列哪些做法有助于降低共享可变状态引发的数据竞争风险
  A. 对共享计数器使用原子操作或加锁保护
  B. 将共享变量复制为线程局部变量后再各自修改
  C. 使用不可变对象并在创建后不再修改其字段
  D. 依赖 volatile 保证复合操作的原子性
  E. 在读取共享集合时直接遍历而不加同步
  答案：A、B、C
  解析：知识点是并发安全。原子操作或锁可保证互斥与可见性；线程局部副本避免共享；不可变对象天然线程安全。volatile 只保证可见性与有序性，不保证 i++ 这类复合操作原子性；无同步遍历共享集合可能抛异常或读到不一致数据。

100. 某后端服务用 Java 编写，方法内先声明了局部变量 List<String> buf 并赋值为 new ArrayList<>()，随后在 try 块中向 buf 添加元素、在 catch 块中打印日志，若要在 catch 块中安全读取 buf 中已添加的元素并保证方法任何异常路径下 buf 都非 null，下列做法中正确的有？
  A. 把 buf 的声明与 new ArrayList<>() 赋值放在 try 块之前，catch 块直接遍历 buf
  B. 在 try 块内声明并初始化 buf，catch 块中通过重新 new ArrayList<>() 后遍历
  C. 把 buf 声明为方法参数传入并初始化为 new ArrayList<>()，catch 块直接遍历
  D. 在 try 块内声明 buf 但不初始化，catch 块中判断 buf 是否为 null 后再遍历
  答案：A、C
  解析：本题考查 Java 局部变量作用域与异常处理中资源可见性。选项0正确：在 try 之前初始化可保证 buf 在 try 与 catch 中均可见且非 null，异常发生时已添加元素仍在。选项2正确：通过参数传入并初始化，作用域覆盖整个方法，catch 中同样可直接安全遍历。选项1错在 try 内声明的 buf 在 catch 中不可见，重新 new 会丢失已添加元素，违背“读取已添加元素”的要求。选项3错在 buf 未初始化，编译期即报错“可能尚未初始化”，且 catch 中为 null 时遍历无意义，无法满足保证非 null 的要求。

101. 关于HTTP状态码302与301的区别，正确的描述是
  A. 302表示资源永久移动且客户端应更新书签
  B. 301表示资源临时移动且后续请求仍用原地址
  C. 302表示资源临时移动且后续请求仍用原地址
  D. 301与302都表示资源临时移动且行为完全一致
  答案：C
  解析：知识点是HTTP重定向语义。302为临时重定向，客户端后续仍应请求原URL，C对；A把302说成永久；B把301说成临时；D混淆两者语义。

102. 关于进程与线程，正确的说法是
  A. 同一进程内的线程共享该进程的地址空间
  B. 线程拥有独立的地址空间而进程没有
  C. 进程切换开销通常小于线程切换开销
  D. 每个线程必须拥有自己独立的堆内存
  答案：A
  解析：知识点是进程与线程资源模型。同进程线程共享地址空间，A对；B把进程线程资源关系说反；C把切换开销关系说反；D线程共享堆，不需要各自独立堆。

103. 对栈执行依次入栈1、2、3、4后，允许在任意时刻出栈，下列不可能得到的出栈序列是
  A. 4,3,2,1
  B. 1,2,3,4
  C. 3,2,4,1
  D. 3,1,2,4
  答案：D
  解析：知识点是栈的合法出栈序列判定。D中先出3需1、2压底，出3后栈顶为2，不可能在2之前先出1，故D不可能；A全入再出合法；B边入边出合法；C按3、2、4、1可操作实现。

104. 在Git中，执行 git reset --soft HEAD~1 后，最近一次提交的改动会
  A. 被彻底删除且无法恢复
  B. 保留在工作区且暂存区为空
  C. 保留在暂存区且工作区不变
  D. 被移动到新分支上
  答案：C
  解析：知识点是reset三种模式区别。--soft只移动HEAD，改动保留在暂存区，C对；A是--hard效果；B是--mixed效果；D与reset无关。

105. 关于SQL注入防御，参数化查询能有效防御的主要原因是
  A. 对用户输入做了HTML转义
  B. 将SQL语句结构与数据分离传输
  C. 限制了数据库账号的查询权限
  D. 对输入长度做了截断处理
  答案：B
  解析：知识点是SQL注入原理与防御。参数化使语句模板与参数分开发送，数据库不把参数当SQL解析，B对；A是防XSS手段；C是权限最小化，非参数化原理；D不能阻止注入。

106. 在编写递归函数时，下列哪些做法有助于避免栈溢出
  A. 确保每次递归调用都向基准情形靠近
  B. 将可尾递归的结构改写为尾递归或迭代
  C. 为递归函数增加全局变量缓存中间结果
  D. 把递归深度上限调大以容纳更多层调用
  E. 在递归前先复制一份完整调用栈
  答案：A、B
  解析：知识点是递归终止与优化。A保证收敛，B减少栈帧，二者对；C缓存不减少递归深度；D只是延后溢出；E复制调用栈不解决深度问题且不可行。

107. Java中String s = "abc"，执行 s = s.concat("d") 后，关于原对象与变量s的说法正确的是
  A. 原对象被修改为abcd
  B. 原对象不变，s指向新对象abcd
  C. 原对象不变，s仍指向abc
  D. 编译报错因为String不可拼接
  答案：B
  解析：知识点是String不可变性与方法返回新对象。concat返回新String，原对象内容不变，s被重新赋值指向新对象。选原对象被修改者混淆了String与StringBuilder；选s仍指向abc者忽略了赋值语句；选编译报错者不了解concat方法存在。

108. Python中执行 print([x*2 for x in range(3)]) 的输出是
  A. [0, 2, 4]
  B. [2, 4, 6]
  C. [0, 1, 2]
  D. [1, 2, 3]
  答案：A
  解析：知识点是列表推导式与range默认起点。range(3)产生0、1、2，乘2得0、2、4。选[2,4,6]者误以为range从1开始；选[0,1,2]者漏掉了乘2；选[1,2,3]者既改起点又漏乘。

109. git中已修改文件但尚未git add，此时执行git commit -m "x" 的结果是
  A. 修改被提交，工作区变干净
  B. 没有内容被提交，提示无变更
  C. 修改被自动加入暂存区并提交
  D. 提交成功但只包含上次暂存内容
  答案：B
  解析：知识点是git暂存区与提交的关系。commit只提交已暂存内容，未add的修改不在暂存区，故无变更可提交。选修改被提交者混淆了工作区与暂存区；选自动加入者以为commit会add；选只包含上次暂存者忽略了本次修改未暂存。

110. 将一个递归函数改写成迭代版本，最通用的辅助手段是
  A. 用数组保存所有中间结果
  B. 显式使用栈模拟调用过程
  C. 把递归改成尾递归
  D. 增加全局变量记录深度
  答案：B
  解析：知识点是递归与迭代的等价转换。递归本质依赖调用栈，通用改写需用显式栈保存现场。选数组保存中间结果者只适用于有重叠子问题的动态规划；选尾递归者仍需编译器支持且非通用；选全局变量记录深度者无法保存局部状态。

111. 在关系数据库中，一个事务对某行加了排他锁后，另一事务再对该行加共享锁会
  A. 立即获得共享锁
  B. 被阻塞直到排他锁释放
  C. 自动升级为排他锁
  D. 直接读取不加锁
  答案：B
  解析：知识点是数据库锁兼容性。排他锁与共享锁不兼容，后申请者需等待前者释放。选立即获得者忽略了互斥性；选自动升级者混淆了锁升级概念；选直接读取不加锁者违反了锁语义。

112. 在Java中，以下关于String、StringBuilder和StringBuffer的说法，正确的是
  A. String对象的字符内容可被修改方法直接改变
  B. StringBuilder的方法均为线程安全同步方法
  C. StringBuffer的方法均为线程安全同步方法
  D. 三者都可直接用作HashMap的键并保证内容相等
  答案：C
  解析：知识点是Java字符串类的可变性与线程安全。StringBuffer对方法加了synchronized，是线程安全的，所以正确。String不可变，任何修改都会返回新对象，A错；StringBuilder未加同步，线程不安全，B错；StringBuilder和StringBuffer未重写equals/hashCode，不能按内容作键，D错。

113. 关于TCP三次握手，客户端发送SYN后收到服务器返回的SYN+ACK，此时客户端需要发送的报文是
  A. 带有ACK标志且确认号为服务器序号加1的报文
  B. 再次带有SYN标志并携带新序号的报文
  C. 带有FIN标志请求关闭连接的报文
  D. 带有RST标志重置连接的报文
  答案：A
  解析：知识点是TCP三次握手第三步。客户端收到SYN+ACK后应发送ACK，确认号为服务器初始序号+1，完成握手，A正确。再次发SYN是重复连接请求，B错；FIN是关闭连接，C错；RST是异常重置，D错。

114. 关于HTTP状态码，下列对应关系正确的是
  A. 301表示请求资源被临时移动到新位置
  B. 401表示服务器内部发生未捕获异常
  C. 403表示服务器理解请求但拒绝执行
  D. 502表示客户端发送的请求语法有误
  答案：C
  解析：知识点是HTTP状态码语义。403 Forbidden表示服务器理解请求但拒绝授权执行，C正确。301是永久重定向，A错；401是未认证，B错；502是网关收到无效响应，D错（请求语法有误是400）。

115. 某后端接口在压测时发现响应时间随并发上升急剧增加，CPU使用率却不高，最可能的原因是
  A. 线程池核心线程数设置过小导致任务排队
  B. 数据库连接池被占满导致请求阻塞等待
  C. JVM堆内存过小频繁触发Full GC
  D. 网络带宽不足导致数据包丢失重传
  答案：B
  解析：知识点是性能瓶颈定位。CPU不高而响应时间陡增，常见于线程阻塞在I/O等待，如数据库连接池耗尽，B最符合。A会表现为线程数受限但CPU可能仍不高，不过排队通常伴随线程池队列增长，相比B更次要；C会表现为CPU高且GC日志频繁；D通常伴随重传和带宽指标异常。

116. 某前端页面在Chrome中样式正常，在Safari中部分flex子项宽度异常收缩，最应优先检查的CSS属性是
  A. flex-shrink及其默认值差异
  B. font-family的字体回退顺序
  C. box-shadow的浏览器前缀
  D. z-index的层叠上下文
  答案：A
  解析：知识点是flex布局的浏览器兼容差异。Safari对flex-shrink默认值和min-width:auto的处理与Chrome不同，易导致子项收缩异常，A正确。字体、阴影、层叠上下文一般不影响flex宽度计算，B、C、D非主因。

117. 在编写单元测试时，下列做法有助于提高测试可靠性的有
  A. 每个测试用例只验证一个明确的行为点
  B. 测试中依赖真实生产数据库以确保数据真实
  C. 使用固定随机种子或可控的伪随机数据
  D. 测试用例之间共享可变全局状态以减少初始化开销
  答案：A、C
  解析：知识点是单元测试原则。A遵循单一职责，便于定位失败；C使随机数据可复现，二者正确。B依赖生产库会使测试慢且不稳定，还可能污染数据；D共享可变全局状态会导致测试顺序耦合、结果不可预测。

118. 在 Java 中，接口里定义的成员变量默认具有的修饰符组合是
  A. public static final
  B. private static final
  C. protected final
  D. public transient
  答案：A
  解析：知识点是 Java 接口成员变量的隐式修饰。接口变量默认 public static final，即公开的静态常量。private static final 错在接口变量必须公开可被实现类访问；protected final 错在接口变量不是受保护访问级别；public transient 错在 transient 用于序列化控制，与接口常量语义无关。

119. Python 中执行 list = [1, 2, 3, 4]; print(list[1:3]) 的输出结果是
  A. [2, 3]
  B. [1, 2]
  C. [2, 3, 4]
  D. [1, 2, 3]
  答案：A
  解析：知识点是 Python 切片左闭右开规则。切片 [1:3] 取下标 1 和 2 的元素，即 2 和 3。选 [1, 2] 的人误把起始下标当成 0；选 [2, 3, 4] 的人误以为右端点闭合；选 [1, 2, 3] 的人同时错在起点和终点。

120. 在关系数据库中，若要查询 student 表中年龄大于 20 且姓名以“张”开头的记录，正确的 WHERE 子句是
  A. WHERE age > 20 AND name LIKE '张%'
  B. WHERE age > 20 OR name LIKE '张%'
  C. WHERE age > 20 AND name = '张%'
  D. WHERE age >= 20 AND name LIKE '%张'
  答案：A
  解析：知识点是 SQL 条件组合与 LIKE 通配符。两个条件需同时满足用 AND，前缀匹配用 '张%'。用 OR 会把只满足一个条件的记录也选出；用等号 = '张%' 会把百分号当普通字符比较；用 '%张' 表示以张结尾而非开头，且 >= 也放宽了边界。

121. 在 Git 中，需要把已经提交到本地仓库但尚未推送的最后一次提交撤销并保留改动到工作区，应使用的命令是
  A. git reset --soft HEAD~1
  B. git reset --hard HEAD~1
  C. git checkout HEAD~1
  D. git revert HEAD
  答案：A
  解析：知识点是 Git reset 三种模式的区别。--soft 只移动 HEAD 保留暂存区和工作区改动。--hard 会丢弃工作区改动；checkout HEAD~1 会切换游离头指针而非撤销提交；revert 会生成一个新提交来抵消原提交，不保留原改动到工作区。

122. 在 TCP 三次握手过程中，客户端收到服务器发来的 SYN+ACK 报文后，会发送的报文是
  A. ACK
  B. SYN
  C. FIN
  D. RST
  答案：A
  解析：知识点是 TCP 建立连接的三次握手流程。第三步客户端发送 ACK 确认服务器同步序列号。SYN 用于第一步发起连接；FIN 用于关闭连接；RST 用于异常复位连接，均不用于握手第三步。

123. 某前端页面在移动端出现点击按钮有 300ms 延迟，最可能的原因是
  A. 浏览器等待双击缩放判定
  B. 按钮绑定了 click 事件
  C. 页面使用了 flex 布局
  D. CSS 选择器层级过深
  答案：A
  解析：知识点是移动端点击延迟的成因。浏览器为区分单击与双击缩放会等待约 300ms。绑 click 事件本身不会造成延迟，是等待机制导致；flex 布局与选择器层级影响的是渲染性能，不产生点击延迟。

124. 在 Python 中，若函数参数使用可变对象作为默认值，例如 def f(x=[])，可能引发的问题是
  A. 多次调用共享同一个默认列表
  B. 每次调用自动复制默认列表
  C. 默认参数无法被修改
  D. 函数定义时立即报语法错误
  答案：A
  解析：知识点是 Python 默认参数的求值时机。默认值在函数定义时求值一次，故多次调用共享同一列表对象。认为会自动复制是对求值时机的误解；认为无法修改与事实相反；该写法语法合法不会报错。

125. 在 Java 中，关于 HashMap 与 Hashtable 的区别，下列描述正确的有
  A. HashMap 允许键为 null，Hashtable 不允许
  B. HashMap 不是线程安全的，Hashtable 是线程安全的
  C. HashMap 继承自 AbstractMap，Hashtable 继承自 Dictionary
  D. HashMap 的迭代器是 fail-fast 的，Hashtable 的枚举器不是
  E. HashMap 默认初始容量是 16，Hashtable 默认初始容量是 11
  答案：A、B、C
  解析：知识点是 Java 两个映射容器的核心差异。HashMap 允许 null 键、非线程安全、继承 AbstractMap；Hashtable 不允许 null 键、线程安全、继承 Dictionary，故前三项正确。第四项错在 HashMap 迭代器 fail-fast 正确但 Hashtable 的 Enumeration 不抛异常，该描述虽部分正确但表述为对比项时并不严谨，选它的人混淆了 fail-fast 与枚举器语义；第五项错在默认容量数字虽常被提及但并非二者本质区别且易记混，本题不将其作为正确项。

126. 下列关于栈和队列的说法，正确的是
  A. 栈按先进先出访问元素
  B. 队列按后进先出访问元素
  C. 栈按后进先出访问元素
  D. 栈和队列都只能从同一端插入和删除
  答案：C
  解析：知识点是栈与队列的访问顺序。栈是后进先出LIFO，C对。A把栈说成先进先出，是队列特性；B把队列说成后进先出，是栈特性；D错在栈只从一端操作，队列从一端插入另一端删除。

127. 关于数据库事务的ACID特性，其中保证事务提交后修改永久保存的是
  A. 原子性
  B. 一致性
  C. 隔离性
  D. 持久性
  答案：D
  解析：知识点是事务ACID含义。持久性D指提交后修改永久保存，D对。原子性指全做或全不做；一致性指约束不被破坏；隔离性指并发事务互不干扰，A、B、C均不符。

128. 在C++中，基类指针指向派生类对象并调用非虚函数时，实际执行的是
  A. 派生类版本
  B. 基类版本
  C. 编译报错
  D. 运行时报错
  答案：B
  解析：知识点是静态绑定与虚函数。非虚函数按指针静态类型绑定，基类指针调用基类版本，B对。A是虚函数才有的动态绑定效果；C、D错在非虚调用合法且不会报错。

129. 前端页面点击按钮后请求接口，用户快速连点多次导致重复提交，下列处置最合理的是
  A. 在请求发出前禁用按钮，请求结束后恢复
  B. 把按钮的点击事件改为双击事件
  C. 让后端忽略所有重复请求即可
  D. 在按钮上增加title提示不要连点
  答案：A
  解析：知识点是前端防重复提交。请求期间禁用按钮可阻止重复触发，A对。B错在双击事件不解决连点且交互异常；C错在后端忽略重复请求可能误丢合法请求；D错在提示不能阻止重复提交。

130. 用二分查找在含1024个有序元素的数组中查找某元素，最多需要比较的次数是
  A. 10
  B. 11
  C. 12
  D. 32
  答案：B
  解析：知识点是二分查找的复杂度与次数计算。每次折半，2^10=1024，但比较次数按向下取整加1为11次。选10是忽略最后一次单元素比较；选12是多算一次；选32是误把它当线性或按位宽估计。

131. 在面向对象设计中，子类覆盖父类方法时把父类方法的访问权限从 public 改为 private，这主要违反了
  A. 里氏替换原则
  B. 开闭原则
  C. 依赖倒置原则
  D. 单一职责原则
  答案：A
  解析：知识点是SOLID原则。子类收紧访问权限会使父类引用无法调用原方法，破坏子类可替换父类的里氏替换原则。开闭原则讲扩展开放修改关闭；依赖倒置讲依赖抽象；单一职责讲一个类只负责一件事，均与权限收紧无关。

132. 在 Git 中，想把当前分支的某一次提交应用到另一个分支且生成新的提交，应使用
  A. git merge
  B. git rebase
  C. git cherry-pick
  D. git revert
  答案：C
  解析：知识点是Git提交级操作。cherry-pick把指定提交的改动复制到当前分支并生成新提交。merge合并整条分支历史；rebase变基重写提交历史；revert是反向提交撤销某次改动，均不实现挑选单次提交复制的效果。

133. Java 中 String s = "a" + "b" + "c"; 与使用 StringBuilder 拼接相比，前者的编译期优化结果是
  A. 每次拼接都创建新的 String 对象
  B. 编译期直接合并为一个字符串常量
  C. 运行时调用 String.concat 三次
  D. 运行时创建三个临时 StringBuffer
  答案：B
  解析：知识点是Java字符串常量折叠。字面量之间的+在编译期就被合并成"abc"常量，不产生多次拼接。选一是把变量拼接的情况套用到字面量；选三误认为调用concat；选四把StringBuilder与StringBuffer混淆且数量错误。

134. 哈希表采用链地址法解决冲突，负载因子过高时通常采取的措施是
  A. 扩容并重新散列所有元素
  B. 把链表改为红黑树以降低高度
  C. 对键重新计算哈希值但桶数不变
  D. 增加每个桶的最大链表长度限制
  答案：A
  解析：知识点是哈希表扩容机制。负载因子过高意味着冲突增多，扩容并rehash能降低平均链长。改为红黑树只在单桶过长时优化；桶数不变重算哈希无法降低负载；限制链长而不扩容会导致插入失败或退化。

135. 在 SQL 中，SELECT COUNT(*) 与 SELECT COUNT(列名) 对含 NULL 值的列统计结果不同，原因是
  A. COUNT(*) 统计所有行，COUNT(列名) 忽略该列为 NULL 的行
  B. COUNT(*) 忽略 NULL，COUNT(列名) 统计所有行
  C. COUNT(*) 只统计主键，COUNT(列名) 统计非主键
  D. COUNT(*) 和 COUNT(列名) 结果始终相同
  答案：A
  解析：知识点是SQL聚合函数对NULL的处理。COUNT(*)统计行数，COUNT(列名)只统计该列非NULL的行。选项二把两者规则颠倒；选项三把COUNT与主键概念混淆；选项四忽略了NULL带来的差异。

136. 某前端页面在移动端点击按钮后出现 300ms 延迟，最合理的优化方案是
  A. 在 viewport 中设置 width=device-width
  B. 把点击事件改为 mouseover 事件
  C. 给按钮增加 CSS 的 transition 动画
  D. 使用 setTimeout 包裹点击回调
  答案：A
  解析：知识点是移动端300ms延迟成因与消除。设置width=device-width可让浏览器取消双击缩放等待。改mouseover会触发频率异常；加过渡动画不影响点击判定；setTimeout只会加重延迟。

137. 以下关于进程与线程的说法中，正确的有
  A. 同一进程内线程共享进程的地址空间
  B. 线程切换通常比进程切换开销小
  C. 进程之间通信必须通过内核提供的机制
  D. 每个线程拥有独立的文件描述符表
  E. 进程崩溃一定会导致同主机其他进程崩溃
  答案：A、B、C
  解析：知识点是进程与线程区别。线程共享地址空间所以选项一对；线程切换不换页表所以选项二对；进程隔离需内核IPC所以选项三对。选项四错在文件描述符表由进程级维护，线程共享；选项五错在进程隔离，一个崩溃不影响其他进程。

138. 某函数在递归深度为 10000 时触发栈溢出，而实际数据规模并不大，最应优先检查的是
  A. 递归是否缺少收敛条件或收敛过慢
  B. 函数返回值类型是否定义错误
  C. 编译器是否开启了最高优化等级
  D. 局部变量是否使用了浮点类型
  答案：A
  解析：知识点是递归栈溢出排查。深度异常大通常因基准条件缺失或递归步长不当。返回类型错误影响结果不影响深度；优化等级只影响性能；浮点类型与递归深度无关。

139. C语言中，表达式 sizeof(char) 与 sizeof('a') 在多数实现下的结果分别是
  A. 1 和 1
  B. 1 和 4
  C. 4 和 1
  D. 4 和 4
  答案：B
  解析：知识点是C语言字符常量的类型。sizeof(char)恒为1字节；字符常量'a'在C中类型为int，故sizeof('a')通常为4。选1和1是把C与C++混淆（C++中字符常量为char）；4和1、4和4则把两者关系完全颠倒。

140. 下列排序算法中，对近乎有序的数组执行时时间复杂度可退化为O(n²)的是
  A. 归并排序
  B. 快速排序
  C. 堆排序
  D. 计数排序
  答案：B
  解析：知识点是排序算法在不同数据分布下的复杂度。快速排序在近乎有序数组上若取首元素为基准，划分极度不平衡退化为O(n²)。归并排序、堆排序稳定保持O(n log n)；计数排序复杂度取决于数值范围并非比较排序，不存在该退化。

141. HTML中给一个块级元素设置 margin-top: 20px 和其上方相邻块级元素 margin-bottom: 30px，两元素垂直间距最终为
  A. 20px
  B. 30px
  C. 50px
  D. 10px
  答案：B
  解析：知识点是CSS外边距塌陷（margin collapsing）。相邻块级元素的上下外边距会合并取较大值，故为30px。选20px或50px忽略了塌陷规则，选10px误以为是取差值。

142. 在Git中，已修改文件但尚未执行 git add，此时执行 git commit -m "fix" 的结果是
  A. 提交该文件的所有修改
  B. 提交为空或提示无暂存内容
  C. 自动暂存并提交该文件
  D. 丢弃该文件的修改
  答案：B
  解析：知识点是Git暂存区机制。commit只提交已暂存内容，未add的修改不会进入本次提交，通常提示无暂存内容。选A把工作区修改当作自动纳入；选C混淆了-a选项的作用；选D把commit误当checkout。

143. 在面向对象中，父类引用指向子类对象并调用被子类重写的方法，运行时执行的是子类版本，这一现象称为
  A. 方法重载
  B. 动态绑定
  C. 方法隐藏
  D. 静态绑定
  答案：B
  解析：知识点是运行时多态。父类引用调用被重写方法时在运行时确定实际类型，执行子类版本，称为动态绑定。方法重载是同类中同名不同参；方法隐藏针对静态方法或字段；静态绑定在编译期确定。

144. HTTP 状态码 302 与 301 的主要区别是
  A. 302 表示永久重定向，301 表示临时重定向
  B. 301 表示永久重定向，302 表示临时重定向
  C. 两者都表示客户端请求语法错误
  D. 302 表示资源未修改，301 表示资源已删除
  答案：B
  解析：知识点是重定向状态码语义。301 为永久重定向，302 为临时重定向；选 302 永久、301 临时是语义颠倒；选语法错误对应 4xx；选资源未修改对应 304、资源删除对应 410 或 404。

145. 在 Git 中，执行 git reset --hard HEAD~1 后，工作区与暂存区会
  A. 保留最近一次提交的改动
  B. 回退到上一次提交并丢弃当前改动
  C. 仅取消暂存但保留工作区改动
  D. 创建一个新的合并提交
  答案：B
  解析：知识点是 git reset 三种模式差异。--hard 会同时重置 HEAD、暂存区和工作区到目标提交；选保留改动是 --soft 或 --mixed 的行为；选仅取消暂存对应 --mixed；选创建合并提交对应 merge 操作。

146. 下列关于进程与线程的说法中，正确的是
  A. 同一进程内线程共享堆和栈
  B. 同一进程内线程共享堆但各有独立栈
  C. 不同进程之间默认共享全局变量
  D. 线程切换开销通常大于进程切换开销
  答案：B
  解析：知识点是进程与线程的资源隔离。同进程线程共享堆等资源但各自有独立栈；选共享栈错误，栈是线程私有的；选进程间默认共享全局变量错误，进程地址空间相互隔离；选线程切换开销更大说反了，线程切换通常更轻量。

147. 在关系数据库中，若表 R 有外键引用表 S 的主键，向 R 插入一条外键值在 S 中不存在的记录，默认行为是
  A. 插入成功并自动在 S 中补建记录
  B. 插入失败并违反参照完整性
  C. 插入成功但该外键被置为 NULL
  D. 插入成功且外键约束被自动删除
  答案：B
  解析：知识点是参照完整性约束。外键值必须在被引用表中存在，否则插入被拒绝；选自动补建记录需要触发器或特定级联设置，并非默认；选置为 NULL 会改变数据语义且非默认；选自动删除约束更不符合约束本意。

148. 在编写涉及共享变量的多线程程序时，下列哪些做法有助于避免数据竞争
  A. 对共享数据的读写使用同一把互斥锁保护
  B. 使用原子操作对共享计数器做自增
  C. 用局部变量缓存共享数据后再写回且不加同步
  D. 使用线程安全的无锁队列传递数据
  E. 为每个线程分配独立的只读数据副本
  答案：A、B、D
  解析：知识点是数据竞争的常见规避手段。互斥锁、原子操作、线程安全无锁结构都能保证共享访问的同步；选先缓存再写回且不加同步属于典型的读改写竞态；选只读副本不涉及共享写，不能解决共享写竞争。

149. 某后端服务上线后出现内存持续增长且 Full GC 后仍不下降，日志显示某缓存 Map 的 key 数量随时间线性增加，最可能的错误环节是
  A. 缓存未设置容量上限或过期淘汰策略
  B. 数据库连接池最大连接数配置过小
  C. 接口返回的 JSON 字段命名不规范
  D. 日志级别被设置为 DEBUG
  答案：A
  解析：知识点是内存泄漏的常见成因排查。key 持续增加且 GC 后不降，说明缓存无淘汰导致对象长期存活；连接池过小会表现为等待而非内存线性增长；字段命名不规范不影响内存；DEBUG 日志会增大日志量但通常不表现为该 Map 的 key 线性增长。

150. 在C语言中，表达式 sizeof(char) + sizeof(int) 在典型32位平台上的求值结果通常是
  A. 2
  B. 4
  C. 5
  D. 8
  答案：C
  解析：知识点是sizeof运算符返回类型占字节数。char为1字节，int在典型32位平台为4字节，1+4=5，故C正确。A只考虑了两个类型各占1字节；B只取了int的字节数而漏加char；D误把int当成8字节（那是64位平台的long long或指针）。

151. 用链表实现栈时，若规定只能在链表头部进行插入和删除，则入栈和出栈操作的时间复杂度分别是
  A. O(1) 和 O(1)
  B. O(1) 和 O(n)
  C. O(n) 和 O(1)
  D. O(n) 和 O(n)
  答案：A
  解析：知识点是链表栈的操作位置与复杂度。头部插入和头部删除都只需改动头指针和常数个指针域，都是O(1)，故A正确。B误以为出栈需要遍历找尾；C误以为入栈需要遍历到尾部；D把两种操作都当成需要遍历，忽略了头部操作的优势。

152. 在Java中，接口里定义的方法默认的访问修饰符是
  A. public
  B. protected
  C. private
  D. default
  答案：A
  解析：知识点是Java接口成员的默认修饰符。接口中的抽象方法默认且只能是public，故A正确。B混淆了类继承中protected的可见范围；C误把类成员的private规则套到接口；D把Java 8引入的default方法关键字当成了访问修饰符。

153. 关于HTTP状态码，下列判定中正确的是
  A. 301表示资源被永久移动到新位置
  B. 302表示请求语法错误无法被服务器理解
  C. 401表示服务器内部处理异常
  D. 503表示客户端未提供身份凭证
  答案：A
  解析：知识点是HTTP状态码语义。301是永久重定向，故A正确。B的302是临时重定向，语法错误应为400；C的401是未认证，服务器内部错误应为500；D的503是服务不可用，未提供凭证应为401。

154. 在JavaScript中，使用 var 声明的变量与使用 let 声明的变量在作用域上的关键区别是
  A. var 声明的变量属于函数作用域，let 声明的变量属于块作用域
  B. var 声明的变量不能重新赋值，let 声明的变量可以重新赋值
  C. var 声明的变量会被提升到全局，let 声明的变量不会被提升
  D. var 声明的变量只能在严格模式下使用，let 声明的变量无此限制
  答案：A
  解析：知识点是var与let的作用域差异。var是函数作用域，let是块作用域，故A正确。B混淆了const与let的重新赋值规则；C中let同样存在提升但处于暂时性死区，并非不提升；D中var在非严格模式同样可用，限制描述错误。

155. 某后端接口上线后偶发超时，日志显示数据库连接池活跃连接数长期贴近上限，而慢查询日志中并无明显慢SQL，此时最应优先排查的是
  A. 连接使用后是否及时归还连接池
  B. 数据库服务器是否未建主键索引
  C. 前端是否并发发起了重复请求
  D. 服务器CPU核数是否少于数据库核数
  答案：A
  解析：知识点是连接池耗尽的常见原因排查。无慢SQL但活跃连接贴顶，典型是连接泄漏或未及时归还，故A正确。B若有慢查询日志会有所体现，与题述矛盾；C重复请求会表现为QPS升高而非连接长期不归还；D核数配置属于容量问题，不解释连接数长期贴顶。

156. 下列关于HTTP状态码的说法，正确的是
  A. 301表示资源被临时移动到新位置
  B. 401表示服务器内部处理出错
  C. 403表示请求被服务器理解但拒绝执行
  D. 502表示客户端请求的URL格式错误
  答案：C
  解析：403表示服务器理解请求但拒绝授权访问，正确；301是永久重定向，临时移动应为302/307；401表示未认证，服务器内部错误是500；502表示网关收到无效响应，URL格式错误是400。

157. 在二叉搜索树中依次插入 5、3、8、1、4 后，中序遍历得到的序列是
  A. 5 3 8 1 4
  B. 1 3 4 5 8
  C. 1 3 5 4 8
  D. 5 3 1 4 8
  答案：B
  解析：二叉搜索树中序遍历得到升序序列，插入元素集合为{1,3,4,5,8}，故为1 3 4 5 8；其余选项均非升序或顺序错误，属于按插入顺序或层序误判。

158. 关于Git中 git rebase 与 git merge 的区别，正确的是
  A. rebase会保留分支合并的历史分叉结构
  B. merge会把当前分支的提交逐个复制到目标分支
  C. rebase会改写提交历史使记录更线性
  D. merge只能用于本地分支不能推送到远程
  答案：C
  解析：rebase将提交在目标分支上重放，形成线性历史，正确；rebase不保留分叉，merge才保留；merge是合并而非复制提交；merge结果同样可推送远程。

159. 某后端接口上线后偶发超时，日志显示数据库连接池等待时间过长，下列处置最合理的是
  A. 直接把连接池最大连接数调到数据库上限
  B. 先排查是否存在长事务或连接泄漏，再调整池参数
  C. 关闭连接池改为每次请求新建连接
  D. 把接口超时时间改大以掩盖问题
  答案：B
  解析：连接池等待通常源于长事务或连接未归还，应先定位根因再调参；盲目调到上限可能压垮数据库；去掉连接池会放大开销；调大超时只是掩盖问题未解决根因。

160. 下列关于进程与线程的说法，正确的有
  A. 同一进程内的线程共享该进程的地址空间
  B. 线程切换通常比进程切换开销小
  C. 进程之间通信必须通过操作系统提供的机制
  D. 每个线程拥有独立的堆内存区域
  E. 多线程程序一定比单线程程序执行更快
  答案：A、B、C
  解析：同进程线程共享地址空间正确；线程切换不需切换页表等，开销通常更小；进程间通信需借助管道、共享内存等OS机制；线程共享堆，各自独立的是栈；多线程受锁竞争与调度影响，未必更快。

161. 关于TCP三次握手，客户端发送SYN后收到服务器回复的SYN+ACK，此时客户端再发送ACK的主要作用是
  A. 确认服务器接收能力正常
  B. 确认客户端已收到服务器的SYN
  C. 协商后续数据传输的窗口大小
  D. 请求服务器立即开始发送数据
  答案：B
  解析：知识点是TCP连接建立过程。第三次ACK用于确认客户端已收到服务器的SYN，使服务器进入ESTABLISHED状态。选项0是第二次握手SYN+ACK的作用；选项2窗口大小在握手报文中协商但发送ACK本身不承担该职责；选项3开始发送数据需连接建立后才进行。

162. 在关系数据库中，若表orders的user_id列允许为NULL，执行 SELECT COUNT(*) FROM orders WHERE user_id <> 100; 与 SELECT COUNT(user_id) FROM orders WHERE user_id <> 100; 的结果差异原因是
  A. COUNT(*)统计所有行，COUNT(user_id)跳过NULL值
  B. COUNT(user_id)会把NULL当作0参与统计
  C. COUNT(*)会自动过滤user_id为100的行
  D. COUNT(user_id)只统计user_id等于100的行
  答案：A
  解析：知识点是SQL聚合函数对NULL的处理。COUNT(*)统计满足条件的行数，COUNT(列)忽略该列为NULL的行，所以两者可能不同。选项1错误，NULL不会转成0；选项2错误，COUNT(*)不过滤user_id=100；选项3错误，COUNT(user_id)统计的是非NULL行而非等于100的行。

163. 前端开发中，CSS选择器 div p 与 div > p 的主要区别是
  A. 前者选所有后代p，后者只选直接子元素p
  B. 前者只选直接子元素p，后者选所有后代p
  C. 前者选同级相邻p，后者选所有后代p
  D. 前者选div自身，后者选div内所有p
  答案：A
  解析：知识点是CSS后代选择器与子选择器。空格表示所有后代，>表示仅直接子元素。选项1把两者说反；选项2相邻同级是+选择器；选项3前者不是选div自身。

164. 在Python中，列表 a = [1, 2, 3]，执行 b = a 后修改 b.append(4)，此时 a 的值是
  A. [1, 2, 3]
  B. [1, 2, 3, 4]
  C. [4, 1, 2, 3]
  D. [1, 2, 4, 3]
  答案：B
  解析：知识点是Python可变对象的引用赋值。b=a让两个变量指向同一列表，修改b会影响a。选项0误以为赋值复制了列表；选项2误以为append插到头部；选项3误以为append插入中间某位置。

165. 关于HTTP状态码，客户端请求一个需要登录才能访问的资源但未携带有效凭证时，服务器通常返回
  A. 301
  B. 401
  C. 403
  D. 404
  答案：B
  解析：知识点是HTTP状态码语义。401表示未认证，需要身份验证。选项0是永久重定向；选项2是已认证但无权限；选项3是资源不存在。

166. 在快速排序中，若每次选取的基准元素都是当前子序列的最大值，则递归树退化的形态是
  A. 完全二叉树
  B. 单支链
  C. 平衡二叉树
  D. 满二叉树
  答案：B
  解析：知识点是快速排序最坏情况。基准总为最大或最小值时划分极不平衡，递归深度为n，退化成单支链。选项0、2、3都表示较平衡的递归结构，与最坏情况不符。

167. 某后端接口在高并发下出现数据库连接池耗尽，日志显示大量请求等待连接超时，以下处置最合适的是
  A. 把连接池最大连接数直接调到数据库上限
  B. 检查慢查询并优化后调整连接池与超时参数
  C. 将数据库连接超时时间改为0表示不超时
  D. 重启应用让连接池重新初始化
  答案：B
  解析：知识点是连接池调优与故障排查。应先定位慢查询等根因，再合理调整连接池和超时。选项0盲目调大可能压垮数据库；选项2不超时会让请求长期挂起；选项3重启只暂时缓解不解决根因。

168. 某前端页面在滚动时频繁触发resize事件导致卡顿，正确的优化处置是
  A. 在事件回调里直接同步读取offsetHeight
  B. 使用防抖或节流限制回调执行频率
  C. 把resize监听改为在每次渲染后手动触发
  D. 提高页面刷新率到120Hz掩盖卡顿
  答案：B
  解析：知识点是浏览器事件优化。防抖/节流可降低高频事件回调执行次数。选项0同步读取布局属性会强制重排加重卡顿；选项2手动触发并不能减少原有高频触发；选项3刷新率与事件触发频率无关。

169. 关于进程与线程，以下说法正确的有
  A. 同一进程内线程共享进程的地址空间
  B. 线程切换通常比进程切换开销小
  C. 进程之间通信必须通过操作系统提供的机制
  D. 一个线程崩溃一定会导致同进程其他线程正常继续
  E. 每个线程拥有独立的文件描述符表
  答案：A、B、C
  解析：知识点是进程与线程区别。线程共享进程地址空间，切换开销较小，跨进程通信需OS机制。选项3错误，线程崩溃可能影响整个进程；选项4错误，文件描述符表通常由同进程线程共享。

170. C 语言中 `int a = 5; printf("%d", a++ + ++a);` 在未定义行为之外，若按从左到右求值且自增立即生效，输出是
  A. 12
  B. 11
  C. 13
  D. 10
  答案：A
  解析：知识点为自增运算符的副作用与求值顺序。若 a=5，a++ 取 5 后 a 变 6，++a 使 a 变 7 取 7，相加得 12。'11' 错在把 ++a 仍按 6 计算；'13' 错在把 a++ 也按自增后的值参与；'10' 错在忽略两次自增只算原值两倍。

171. Java 中 `String s1 = "abc"; String s2 = new String("abc");` 则 `s1 == s2` 与 `s1.equals(s2)` 的结果分别是
  A. false 和 true
  B. true 和 true
  C. false 和 false
  D. true 和 false
  答案：A
  解析：知识点为 Java 字符串常量池与对象引用比较。s1 指向常量池对象，s2 指向堆中新对象，故 == 比较引用为 false，equals 比较内容为 true。'true 和 true' 错在忽略 new 创建新对象；'false 和 false' 错在误以为 equals 也比较引用；'true 和 false' 错在颠倒两者语义。

172. 下列排序算法中，对包含大量重复元素的数组通常表现较好且平均时间复杂度为 O(n log n) 的是
  A. 三路快速排序
  B. 冒泡排序
  C. 直接插入排序
  D. 选择排序
  答案：A
  解析：知识点为排序算法对重复元素的适应性。三路快排将数组分为小于、等于、大于三部分，重复元素集中处理，平均 O(n log n)。冒泡、插入、选择在最坏或平均下为 O(n^2)，不适合大规模数据。

173. 在 MySQL 中，对 `WHERE age > 18` 的查询，若 age 列上已建普通索引，通常能提升效率的原因是
  A. 索引减少需要扫描的行数
  B. 索引把数据行按 age 重新物理排序
  C. 索引会自动缓存查询结果
  D. 索引把 age 转换为哈希值存储
  答案：A
  解析：知识点为 B+ 树索引的作用。索引通过有序结构快速定位满足范围条件的行，减少全表扫描。'重新物理排序' 错在 InnoDB 聚簇索引按主键组织，普通索引不改变数据行物理顺序；'自动缓存查询结果' 是查询缓存或缓冲池功能，非索引本身；'哈希值存储' 是哈希索引特点，普通 B+ 树索引不是。

174. 下列关于 TCP 三次握手中第三次握手的描述，正确的是
  A. 客户端收到 SYN+ACK 后发送 ACK 确认
  B. 服务器收到 SYN 后发送 ACK 确认
  C. 客户端发送 SYN 并进入 SYN_SENT 状态
  D. 服务器发送 FIN 并进入 CLOSE_WAIT 状态
  答案：A
  解析：知识点为 TCP 三次握手流程。第三次握手是客户端收到服务器的 SYN+ACK 后回复 ACK。'服务器收到 SYN 后发送 ACK' 描述的是第二次握手的部分动作；'客户端发送 SYN' 是第一次握手；'服务器发送 FIN' 属于四次挥手，不是握手阶段。

175. 某后端接口在高并发下出现数据库连接池耗尽，日志显示大量请求等待连接，最优先的处置是
  A. 检查慢查询与连接泄漏并设置合理超时
  B. 直接把连接池最大连接数调到最大
  C. 重启数据库释放所有连接
  D. 把接口改为同步阻塞调用
  答案：A
  解析：情境案例，考查连接池耗尽时的排查思路。优先定位慢查询或未释放连接，并设置获取连接超时避免雪崩。'调到最大' 可能压垮数据库；'重启数据库' 治标不治本且影响面大；'改为同步阻塞' 会加剧线程占用，方向相反。

176. 在 Python 中执行 a=[1,2,3]; b=a; b.append(4) 后，a 的值是
  A. [1,2,3]
  B. [1,2,3,4]
  C. [4,1,2,3]
  D. [1,2,3,4,4]
  答案：B
  解析：知识点是可变对象的引用语义。b=a 使 b 与 a 指向同一列表对象，append 修改该对象，故 a 也变为 [1,2,3,4]。选项 [1,2,3] 错在误以为发生了拷贝；[4,1,2,3] 错在误以为 append 在头部插入；[1,2,3,4,4] 错在误以为 append 会重复添加。

177. 数据库中事务的隔离级别从低到高排列，正确的是
  A. 读未提交、读已提交、可重复读、串行化
  B. 读已提交、读未提交、可重复读、串行化
  C. 可重复读、读已提交、读未提交、串行化
  D. 串行化、可重复读、读已提交、读未提交
  答案：A
  解析：知识点是事务隔离级别的标准顺序。由低到高为读未提交、读已提交、可重复读、串行化。选项把读已提交与读未提交对调；选项把可重复读置于最低；选项是从高到低排列。

178. 对单链表进行头插法建表时，若头指针为 head，新结点为 p，正确的操作顺序是
  A. p->next=head; head=p;
  B. head=p; p->next=head;
  C. p->next=head->next; head->next=p;
  D. head->next=p; p->next=head;
  答案：A
  解析：知识点是单链表头插法指针操作。应先让新结点指向原首结点，再更新头指针。选项先改 head 再让 p 指向 head 会形成自环；选项是中间插入的做法；选项先改 head->next 再让 p 指向 head 会破坏链表结构。

179. 关于HTTP状态码，服务器成功处理请求但返回的响应体为空（如204），应使用的状态码是
  A. 200
  B. 201
  C. 204
  D. 304
  答案：C
  解析：知识点是HTTP状态码语义。204 No Content表示成功但无响应体。200默认带响应体；201表示资源已创建；304表示资源未修改需用缓存。三者语义均与“成功且无内容”不符。

180. 在面向对象中，子类重写父类方法时，若将父类方法的访问权限public改为子类的private，结果是
  A. 编译通过，运行时按private调用
  B. 编译错误，子类不能缩小访问权限
  C. 编译通过，子类方法对外不可见
  D. 编译通过，父类引用调用时按private处理
  答案：B
  解析：知识点是重写时访问权限不能比父类更严格。子类重写方法权限必须大于等于父类，否则编译错误。选项说编译通过均错误；说父类引用按private处理不成立，因编译阶段已失败。

181. 在C语言中，表达式 5 / 2 * 2.0 的运算结果类型和值分别是
  A. double 类型，值为 4.0
  B. int 类型，值为 4
  C. double 类型，值为 5.0
  D. int 类型，值为 5
  答案：A
  解析：知识点：整数除法与隐式类型转换。5/2 先按整数除法得 2，再与 2.0 相乘时 2 被提升为 double，结果为 4.0，类型为 double。选项B错在忽略了后面与 2.0 相乘已把结果变成 double；选项C错在误以为 5/2 会保留小数得 2.5；选项D错在同时算错商和类型。

182. 下列关于 TCP 三次握手中第二次握手内容的描述，正确的是
  A. 客户端发送 SYN 并携带自己的初始序号
  B. 服务器发送 SYN 并携带自己的初始序号、确认客户端的序号
  C. 客户端发送 ACK 确认服务器的序号
  D. 服务器发送 ACK 但不携带任何序号
  答案：B
  解析：知识点：TCP 三次握手过程。第二次握手是服务器回 SYN+ACK，携带自身初始序号并确认客户端序号。选项A是第一次握手；选项C是第三次握手；选项D错在第二次握手必须携带服务器初始序号。

183. 某后端接口偶发超时，日志显示数据库连接池活跃连接数长时间等于最大连接数，最先应排查的是
  A. 增加服务器 CPU 核数
  B. 检查是否存在未释放连接或长事务
  C. 把连接池最大连接数调小
  D. 将数据库字符集改为 utf8mb4
  答案：B
  解析：知识点：连接池耗尽排查。活跃连接长期打满通常是连接未归还或长事务占用。选项A与连接占用无直接关系；选项C会加剧等待；选项D与连接耗尽无关。

184. 前端页面在移动端出现横向滚动条，最可能的原因是
  A. 某个元素宽度超出视口或存在固定宽度
  B. 图片未设置 alt 属性
  C. CSS 选择器优先级过低
  D. JavaScript 未使用严格模式
  答案：A
  解析：知识点：移动端布局溢出的常见原因。超出视口的元素或固定宽度是横向滚动的主因。选项B影响可访问性而非布局；选项C影响样式覆盖而非溢出；选项D与布局溢出无关。

185. 在 Java 中，接口 InterfaceA 声明了方法 void run(); 下列类声明中能通过编译的是
  A. class B implements InterfaceA { public void run(){} }
  B. class B implements InterfaceA { void run(){} }
  C. class B extends InterfaceA { public void run(){} }
  D. class B implements InterfaceA { public int run(){return 0;} }
  答案：A
  解析：知识点是接口实现：实现类必须用public重写接口方法，且签名一致。A项用public修饰且返回void，正确。B项缺少public会降低访问权限；C项类不能extends接口；D项返回类型int与void不兼容。

186. 在链表中删除指针 p 所指的中间结点（已知 p 有后继结点），在无法访问头指针时的常用做法是
  A. 把后继结点的值复制到 p 再删除后继结点
  B. 直接释放 p 并把前驱指针置空
  C. 把 p 指向头结点再释放原结点
  D. 交换 p 与后继结点的值后释放后继结点
  答案：A
  解析：知识点是单链表删除特定结点的技巧：将后继值覆盖到p，再删后继，等效删除p。B项无前驱指针无法置空前驱；C项会丢失链表；D项只交换值仍无法释放p。

187. 关于 HTTP 状态码 302 与 301 的区别，描述正确的是
  A. 301 表示永久重定向，302 表示临时重定向
  B. 301 表示临时重定向，302 表示永久重定向
  C. 301 表示请求成功，302 表示资源未找到
  D. 301 表示服务器错误，302 表示客户端错误
  答案：A
  解析：知识点是HTTP重定向状态码：301为永久移动，302为临时移动。B项把两者语义颠倒；C项混淆了200和404；D项混淆了5xx与4xx类别。

188. 在 Git 中，将本地已提交但尚未推送的最近一次提交撤销并保留修改到工作区，应使用
  A. git reset --soft HEAD~1
  B. git reset --hard HEAD~1
  C. git revert HEAD
  D. git checkout HEAD~1
  答案：A
  解析：知识点是git reset三种模式：--soft保留改动在暂存区（此处保留修改）。B项--hard会丢弃改动；C项revert生成反向提交而非撤销；D项checkout会切换提交导致分离头指针。

189. 在 C 语言中，表达式 5 / 2 * 2.0 的求值结果是
  A. 5.0
  B. 4.0
  C. 2.5
  D. 2.0
  答案：B
  解析：知识点：整数除法与类型提升。5/2 先按整数除法得 2，再与 2.0 相乘得 4.0。错误项分析：5.0 是把整个表达式当浮点除法算；2.5 是先把 5 转成 5.0 再做除法；2.0 是误认为整数除法结果再取整。

190. Java 中 String s = "a"; s = s + "b"; 执行后关于对象的说法正确的是
  A. 原对象被修改为 "ab"
  B. 创建了新对象，s 指向新对象
  C. 字符串常量池中的 "a" 被替换
  D. 编译报错，String 不可拼接
  答案：B
  解析：知识点：String 不可变性。String 对象不可变，拼接会生成新对象并让引用指向它。错误项分析：原对象被修改违反不可变性；常量池中的内容不会被替换；String 支持 + 拼接不会编译报错。

191. TCP 三次握手中，客户端收到服务器发来的 SYN+ACK 后应发送的报文段是
  A. SYN
  B. ACK
  C. FIN
  D. RST
  答案：B
  解析：知识点：TCP 建连流程。第三步客户端回 ACK 确认服务器序号，连接建立。错误项分析：SYN 是第一步请求；FIN 用于断开连接；RST 用于异常重置连接。

192. 进程从运行态因等待 I/O 完成而进入的状态是
  A. 就绪态
  B. 阻塞态
  C. 终止态
  D. 新建态
  答案：B
  解析：知识点：进程状态转换。等待 I/O 属于阻塞原因，进入阻塞态。错误项分析：就绪态是等待 CPU；终止态是进程结束；新建态是刚被创建尚未就绪。

193. 哈希表在负载因子过高时通常采取的措施是
  A. 扩大桶数组并重新散列
  B. 直接删除冲突元素
  C. 改用线性查找逐个比对
  D. 冻结插入操作直到有空位
  答案：A
  解析：知识点：哈希表扩容机制。负载因子过高会扩容并 rehash 以降低冲突。错误项分析：删除冲突元素会丢数据；线性查找不是哈希表正常查询路径；冻结插入无法解决已有冲突。

194. 关于二叉搜索树与平衡二叉搜索树（如 AVL 树）的差异，下列描述正确的有
  A. 普通二叉搜索树在极端插入序列下可能退化为链表
  B. AVL 树通过旋转将左右子树高度差控制在常数范围
  C. 普通二叉搜索树的查找最坏时间复杂度为 O(log n)
  D. AVL 树的插入操作一定比普通二叉搜索树更快
  答案：A、B
  解析：知识点：BST 与平衡树特性。极端有序插入会使 BST 退化成链表，AVL 靠旋转维持高度平衡。错误项分析：普通 BST 最坏是 O(n) 而非 O(log n)；AVL 因旋转维护，插入开销通常更大。

195. 对于单链表中指针p所指结点，要删除其后继结点q，正确的指针操作是
  A. p->next=q->next; free(q);
  B. q->next=p->next; free(p);
  C. p->next=q; free(q->next);
  D. free(q); p->next=q->next;
  答案：A
  解析：知识点是链表删除结点的顺序。删除q需先让p跳过q指向q的后继，再释放q，A对。B修改方向反了，使q指向p的后继，破坏链表；C先让p指向q再释放q的后继，释放的是错误结点；D先释放q后访问q->next属于释放后使用，是未定义行为。

196. HTML中要让一个块级元素在父容器内水平居中且自身宽度为父容器的一半，较合适的是
  A. 设置 width:50%; margin:0 auto;
  B. 设置 width:50%; float:left;
  C. 设置 width:50%; position:absolute; left:0;
  D. 设置 width:50%; display:inline;
  答案：A
  解析：知识点是块级元素水平居中的常用方案。定宽块级元素用 margin:0 auto 可水平居中，A对。B使用float会左浮动而非居中；C绝对定位靠左不会居中；D把块级改为行内，宽度设置往往失效且不居中。

197. 关于TCP三次握手，客户端发送SYN并收到服务器SYN+ACK后，客户端再发送的报文是
  A. ACK
  B. SYN
  C. FIN
  D. RST
  答案：A
  解析：知识点是TCP建立连接的第三步。第三次握手客户端发送ACK确认服务器的SYN，A对。B重复发送SYN会打乱握手；C的FIN用于关闭连接；D的RST用于异常复位连接。

198. SQL中要查询student表每个班级的人数并只显示人数大于30的班级，正确的语句是
  A. SELECT class,COUNT(*) FROM student GROUP BY class HAVING COUNT(*)>30;
  B. SELECT class,COUNT(*) FROM student WHERE COUNT(*)>30 GROUP BY class;
  C. SELECT class,COUNT(*) FROM student GROUP BY class WHERE COUNT(*)>30;
  D. SELECT class,COUNT(*) FROM student HAVING COUNT(*)>30 GROUP BY class;
  答案：A
  解析：知识点是分组过滤用HAVING。聚合条件COUNT(*)>30必须放在GROUP BY之后的HAVING中，A对。B把聚合条件放入WHERE，执行顺序不允许；C的WHERE写在GROUP BY之后语法错误；D把HAVING写在GROUP BY之前，子句顺序错误。

199. 函数f定义如下：int f(int n){ return n<=1?1:n*f(n-1);} 调用f(5)的返回值是
  A. 120
  B. 24
  C. 60
  D. 720
  答案：A
  解析：知识点是递归与阶乘。f(5)=5×4×3×2×1=120，A对。B是4的阶乘；C错算为5×4×3；D是6的阶乘。

200. 某后端接口在压测中偶发返回旧数据，排查发现使用了本地缓存但更新数据库后未失效缓存。正确的修复方向是
  A. 写数据库成功后主动删除或更新对应缓存键
  B. 把缓存过期时间调大以减少回源
  C. 在读取缓存前先sleep等待数据库同步
  D. 将缓存改为永久有效避免频繁失效
  答案：A
  解析：知识点是缓存与数据库一致性。写库后应让缓存失效或更新，A对。B延长过期只会让旧数据存活更久；C用sleep掩盖问题且不可靠；D永久有效会使旧数据永远无法纠正。

201. 前端页面中一个按钮点击后应只触发一次提交，但测试发现连点会重复提交。开发在事件处理函数中未做防抖也未禁用按钮，正确的修复环节是
  A. 在提交开始时禁用按钮并在请求结束后恢复
  B. 把click事件改为mouseover事件
  C. 在提交函数里用setTimeout延迟10秒再发送
  D. 把按钮的type由button改为submit
  答案：A
  解析：知识点是重复提交的防护。提交期间禁用按钮可阻止连点，A对。B用mouseover会引入错误触发；C延迟10秒不解决连点且体验差；D改为submit在表单中反而更易触发默认提交。

202. 关于程序调试，下列做法中有助于定位偶发缺陷的有
  A. 在关键分支增加带时间戳的日志记录
  B. 用版本控制对比引入缺陷前后的代码差异
  C. 复现时记录输入数据、环境版本和操作步骤
  D. 把疑似出错语句注释掉后直接发布上线
  E. 将异常捕获后统一忽略以避免程序中断
  答案：A、B、C
  解析：知识点是调试与缺陷定位方法。A的日志可还原执行路径；B的差异对比能定位变更引入点；C的记录便于稳定复现，三者均对。D注释代码后上线会把未验证状态带入生产；E忽略异常会掩盖错误、丢失堆栈，均不利于定位缺陷。

203. 在关系型数据库中，若要保证一个事务中的多条更新要么全部生效要么全部回滚，应依赖事务的哪个特性
  A. 原子性
  B. 一致性
  C. 隔离性
  D. 持久性
  答案：A
  解析：知识点是事务ACID特性。原子性保证事务内操作不可分割，要么全做要么全不做。一致性指事务前后数据满足约束；隔离性指并发事务互不干扰；持久性指提交后结果永久保存，均不直接负责整体回滚。

204. 在链表中，与数组相比更适合使用链表的场景是
  A. 需要按下标随机访问元素
  B. 需要频繁在中间位置插入和删除
  C. 需要元素在内存中连续存储
  D. 需要利用CPU缓存获得高访问速度
  答案：B
  解析：知识点是链表与数组的结构差异。链表插入删除只需改指针，适合频繁中间增删。按下标随机访问、连续存储、缓存友好都是数组的优势，链表均不擅长。

205. 在SQL中，若要对查询结果按某列分组并只保留组内记录数大于3的组，应使用
  A. ORDER BY ... HAVING
  B. GROUP BY ... HAVING
  C. GROUP BY ... WHERE
  D. ORDER BY ... WHERE
  答案：B
  解析：知识点是GROUP BY与HAVING的配合。分组用GROUP BY，对分组结果过滤用HAVING。ORDER BY只排序不过滤；WHERE在分组前过滤单行，不能对聚合结果过滤；ORDER BY与WHERE组合无法实现分组计数过滤。

206. 某后端接口在高并发下偶发返回旧数据，排查发现读请求先于同一用户的写请求完成。为降低该现象，合理的改进是
  A. 把写请求改为异步后立即返回成功
  B. 读请求前先查询从库延迟时间再决定是否重试
  C. 将读写都路由到同一从库并关闭主库
  D. 对写请求增加随机延迟以错开流量
  答案：B
  解析：知识点是主从复制延迟导致的一致性读问题。先查从库延迟再决定重试可避免读到旧数据。异步写立即返回会加剧不一致；读写都走从库且关主库无法写入；给写请求加随机延迟不能保证读请求看到最新数据。

207. 快速排序在每轮划分后对左右子区间递归处理，其平均时间复杂度和最坏时间复杂度分别是
  A. O(nlogn) 与 O(n^2)
  B. O(nlogn) 与 O(nlogn)
  C. O(n^2) 与 O(n^2)
  D. O(nlogn) 与 O(n)
  答案：A
  解析：知识点是快排复杂度分析。平均情况下划分较均衡为 O(nlogn)，最坏如已有序且取端点为基准时退化为 O(n^2)，故 A 对；B 忽略了退化情形；C 把平均也当成最坏；D 的最坏 O(n) 不成立。

208. Java 中父类引用指向子类对象后调用被重写的方法，实际执行的是
  A. 父类中定义的方法
  B. 子类中重写的方法
  C. 编译时随机决定
  D. 子类中新增的普通方法
  答案：B
  解析：知识点是动态绑定。运行时根据对象实际类型调用被重写的方法，故 B 对；A 是静态绑定才会发生的情况；C 方法调用不会随机决定；D 新增方法未被父类声明无法通过父类引用调用。

209. 在TCP连接释放的四次挥手过程中，主动关闭方在收到对方FIN后进入的状态是
  A. CLOSE_WAIT
  B. TIME_WAIT
  C. FIN_WAIT_2
  D. LAST_ACK
  答案：C
  解析：知识点是TCP状态机。主动关闭方先发FIN进入FIN_WAIT_1，收到对方ACK后进入FIN_WAIT_2，故 C 对；A 是被动关闭方收到FIN后的状态；B 是主动关闭方最终等待2MSL的状态；D 是被动关闭方发FIN后等待ACK的状态。

210. 下列SQL语句中，用于从 employees 表删除所有行但保留表结构的是
  A. DELETE FROM employees
  B. TRUNCATE TABLE employees
  C. DROP TABLE employees
  D. ALTER TABLE employees DROP
  答案：B
  解析：知识点是DDL与DML区别。TRUNCATE 快速清空数据但保留表定义，故 B 对；A 也删数据但逐行删除且可回滚、可能触发触发器，与题问“保留结构”的最典型高效命令不符；C 连表结构一起删除；D 语法不完整用于删除列。

211. HTML中要让一个块级元素在父容器内水平居中且父容器宽度固定，下列CSS写法正确的是
  A. margin: 0 auto;
  B. text-align: center;
  C. float: left;
  D. position: absolute;
  答案：A
  解析：知识点是块级元素水平居中。设置左右外边距为 auto 且元素有确定宽度即可居中，故 A 对；B 是行内内容居中，对块级元素本身无效；C 使元素左浮动；D 绝对定位需配合 left/right 才可能居中，单独写不居中。

212. 在哈希表中采用链地址法解决冲突，当装填因子过大时最直接的影响是
  A. 查找平均长度增加
  B. 哈希函数失效
  C. 元素无法插入
  D. 关键字必须重新排序
  答案：A
  解析：知识点是哈希冲突与装填因子。装填因子大意味着冲突多、链变长，平均查找长度增加，故 A 对；B 哈希函数本身仍可计算；C 链地址法仍可插入只是变慢；D 哈希不要求关键字有序。

213. 前端页面在浏览器中点击按钮无反应，控制台报“Cannot read properties of null (reading 'addEventListener')”，最可能的原因是
  A. 脚本在DOM元素加载前执行导致取到null
  B. 按钮的CSS样式设置了display:none
  C. 事件监听器绑定到了错误的鼠标事件类型
  D. 浏览器禁用了JavaScript
  答案：A
  解析：情境案例。报错说明对 null 调用了 addEventListener，通常是脚本执行时目标元素尚未渲染，故 A 对；B 隐藏元素不影响绑定；C 绑定错误事件类型不会报 null；D 禁用JS则整个脚本不执行也不会出现该错误。

214. 下列排序算法中，若要求排序稳定且时间复杂度为O(nlogn)，应选择
  A. 归并排序
  B. 快速排序
  C. 堆排序
  D. 希尔排序
  答案：A
  解析：知识点是排序稳定性与复杂度。归并排序稳定且为 O(nlogn)，故 A 对；B 快排不稳定；C 堆排序不稳定；D 希尔排序不稳定且复杂度依赖增量序列。

215. 关于HTTP与HTTPS，下列描述正确的有
  A. HTTPS在HTTP基础上加入TLS加密传输
  B. HTTP默认端口80，HTTPS默认端口443
  C. HTTPS可以防止中间人篡改响应内容
  D. HTTP请求方法GET和POST在语义上完全等价
  E. HTTPS能保证服务器绝对不被入侵
  答案：A、B、C
  解析：知识点是HTTP与HTTPS特性。A对，HTTPS即HTTP over TLS；B对，默认端口分别为80和443；C对，TLS提供完整性校验防篡改；D错，GET用于获取、POST用于提交，语义不同；E错，HTTPS只保障传输安全，不能防止服务器被入侵。

216. HTTP状态码中表示客户端请求的资源需要身份认证且尚未提供凭证的是
  A. 301
  B. 401
  C. 403
  D. 404
  答案：B
  解析：知识点是HTTP状态码语义。401 Unauthorized表示需要认证。选0的301是永久重定向；选2的403是已认证但无权限；选3的404是资源不存在。

217. 在Git中已提交了敏感文件config.env，现在想从后续提交中移除但保留本地文件，应使用
  A. git rm config.env
  B. git rm --cached config.env
  C. git delete config.env
  D. git reset config.env
  答案：B
  解析：知识点是Git索引与工作区区分。git rm --cached只从版本控制移除、保留本地文件。选0的git rm会同时删除本地文件；选2不是Git命令；选3的reset是移动HEAD或取消暂存，不专门做取消跟踪。

218. 进程从运行态因为时间片用完而转入的状态是
  A. 阻塞态
  B. 就绪态
  C. 终止态
  D. 新建态
  答案：B
  解析：知识点是进程状态转换。时间片用完仍可运行，只是让出CPU，转入就绪态等待再次调度。选0的阻塞态需等待I/O等事件；选2终止态是进程结束；选3新建态是创建阶段。

219. 下列排序算法中，稳定且平均时间复杂度为O(n log n)的是
  A. 快速排序
  B. 堆排序
  C. 归并排序
  D. 选择排序
  答案：C
  解析：知识点是排序算法稳定性与复杂度。归并排序稳定且平均O(n log n)。选0快排不稳定且最坏O(n^2)；选1堆排不稳定；选3选择排序不稳定且O(n^2)。

220. 在 Python 中执行表达式 3 * 1 ** 2 的结果是
  A. 9
  B. 6
  C. 3
  D. 1
  答案：C
  解析：知识点是运算符优先级：** 的优先级高于 *，先算 1 ** 2 = 1，再算 3 * 1 = 3。选项 9 错在把乘法先算成 3*1=3 再平方；选项 6 错在把 1**2 当成 1*2；选项 1 错在把整个表达式当成 3*1 后误将 ** 当无效运算。

221. HTTP 状态码 301 与 302 的关键区别在于
  A. 301 表示资源永久迁移，302 表示临时迁移
  B. 301 用于 HTTPS，302 用于 HTTP
  C. 301 由客户端缓存，302 由服务器缓存
  D. 301 只能用于 GET，302 只能用于 POST
  答案：A
  解析：知识点是重定向语义：301 表示永久移动，客户端与搜索引擎会更新链接；302 表示临时移动，后续请求仍用原 URL。选项 B 与协议无关；选项 C 缓存主体说反了；选项 D 与请求方法无必然绑定。

222. Git 中执行 git reset --soft HEAD~1 后，被撤销的那次提交的改动会处于
  A. 工作区未暂存状态
  B. 暂存区已暂存状态
  C. 已彻底丢弃状态
  D. 远程分支已同步状态
  答案：B
  解析：知识点是 reset 三种模式：--soft 只移动 HEAD，改动保留在暂存区；--mixed 放回工作区；--hard 丢弃改动。选项 A 是 --mixed 的效果；选项 C 是 --hard 的效果；选项 D 与本地 reset 无关。

223. 前后端分离项目中，浏览器发起跨域请求被拦截，服务端已设置 Access-Control-Allow-Origin 为具体域名，但携带 Cookie 的请求仍失败，最可能缺少的响应头是
  A. Access-Control-Allow-Credentials: true
  B. Access-Control-Allow-Methods: GET
  C. Content-Type: application/json
  D. Cache-Control: no-cache
  答案：A
  解析：知识点是 CORS 携带凭证：当请求带 Cookie 时，服务端必须返回 Access-Control-Allow-Credentials: true，且 Allow-Origin 不能为 *。选项 B 只声明允许方法；选项 C 是响应体类型；选项 D 与跨域凭证无关。

224. C 语言中，函数内定义的 static 局部变量在程序运行期间的生命周期是
  A. 整个程序运行期间
  B. 所在函数每次调用期间
  C. 所在源文件编译期间
  D. 所在线程运行期间
  答案：A
  解析：知识点是 static 局部变量的存储期。正确项是整个程序运行期间，因为 static 局部变量存放在静态存储区，只初始化一次并保持值到程序结束。所在函数每次调用期间是普通自动变量的生命周期。所在源文件编译期间混淆了编译期与运行期。所在线程运行期间把存储期与线程局部存储混淆。

225. 在 HTTP 协议中，状态码 301 与 302 的核心区别是
  A. 301 表示资源永久移动，302 表示临时移动
  B. 301 表示请求成功，302 表示请求重定向
  C. 301 用于 HTTPS，302 用于 HTTP
  D. 301 由服务器返回，302 由客户端返回
  答案：A
  解析：知识点是 HTTP 重定向状态码语义。正确项指出 301 是永久重定向、302 是临时重定向，影响缓存与搜索引擎更新。请求成功是 2xx 系列。协议类型与状态码无关。重定向状态码都由服务器返回。

226. 在 SQL 中，对分组结果进行筛选应使用的子句是
  A. HAVING
  B. WHERE
  C. ORDER BY
  D. GROUP BY
  答案：A
  解析：知识点是 SQL 子句执行顺序。正确项 HAVING 用于对 GROUP BY 之后的分组结果过滤。WHERE 在分组前过滤行，不能直接用聚合函数。ORDER BY 用于排序。GROUP BY 用于分组本身而非筛选分组。

227. JavaScript 中使用 const 声明的对象，下列操作会抛出错误的是
  A. 对该对象重新赋值另一个对象
  B. 修改该对象的一个属性值
  C. 向该对象添加一个新属性
  D. 删除该对象的一个已有属性
  答案：A
  解析：知识点是 const 的不可变性范围。正确项重新赋值会抛错，因为 const 绑定不可重新指向。修改属性、添加属性、删除属性都不改变绑定本身，默认允许（除非对象被冻结）。

228. 开发人员发现线上接口返回 500，日志显示空指针异常，下一步最合理的处置是
  A. 根据堆栈定位空指针代码行并复现修复
  B. 立即重启服务器以恢复服务
  C. 直接回滚到上一版本并关闭日志
  D. 把该接口的返回状态码改为 200
  答案：A
  解析：知识点是线上故障排查流程。正确项依据堆栈定位根因并复现修复，避免问题复发。重启可能暂时恢复但未解决根因。回滚并关闭日志会丢失排查信息。改状态码属于掩盖问题。

229. 在 Git 中，执行 git reset --soft HEAD~1 后工作区与暂存区的变化是
  A. 撤销最近一次提交，改动保留在暂存区
  B. 撤销最近一次提交，改动保留在工作区
  C. 撤销最近一次提交并丢弃所有改动
  D. 只撤销暂存区内容，不改变提交历史
  答案：A
  解析：知识点是 git reset 三种模式区别。正确项 --soft 只移动 HEAD，最近提交的改动仍在暂存区。--mixed（默认）才把改动放回工作区。--hard 才丢弃改动。第四项描述的是 git restore --staged 的作用。

230. 在 C 语言中，函数参数采用值传递方式，若要在被调函数中修改主调函数里某个 int 变量的值，调用时应传入什么？
  A. 该变量的值
  B. 该变量的地址
  C. 该变量的名字
  D. 该变量的类型
  答案：B
  解析：知识点：C 语言值传递与指针传参。正确项“该变量的地址”对，因为只有传地址，被调函数才能通过指针解引用修改主调变量。错误项“该变量的值”错在值传递只复制副本，修改不影响原变量；“该变量的名字”错在 C 语言没有按名传递机制；“该变量的类型”错在类型不是可传递的实参。

231. 某程序员用 Python 读取一个 2GB 的日志文件并统计关键词出现次数，程序运行后内存迅速涨到数 GB 并崩溃，最可能的原因是？
  A. 使用了 readlines() 一次性读入所有行
  B. 使用了 with open() 管理文件句柄
  C. 使用了 for line in f 逐行迭代
  D. 使用了 str.count() 统计关键词
  答案：A
  解析：知识点：大文件流式处理。正确项对，readlines() 会把所有行载入列表，2GB 文件极易撑爆内存。with open 是正确释放资源做法，for line in f 是逐行流式读取，str.count 只是字符串方法，均不会导致整体载入内存。

232. Java 中 String 与 StringBuilder 都能拼接字符串，循环内大量拼接时应优先选用 StringBuilder，主要原因是？
  A. StringBuilder 拼接结果更准确
  B. String 是不可变对象，每次拼接产生新对象
  C. StringBuilder 支持更多字符编码
  D. String 无法在循环中使用
  答案：B
  解析：知识点：Java 字符串不可变性。正确项对，String 不可变，每次 + 拼接都会新建对象，循环中开销大。StringBuilder 拼接结果与 String 一致，编码支持非其核心优势，String 本身可在循环中使用。

233. JavaScript 中使用 == 比较 0 与空字符串 ''，结果为 true，而使用 === 结果为 false，原因是？
  A. == 会先做类型转换再比较
  B. === 只比较引用地址
  C. == 对字符串有特殊排序规则
  D. === 会忽略 NaN 的情况
  答案：A
  解析：知识点：JS 宽松相等与严格相等。正确项对，== 在类型不同时会做隐式转换，0 与 '' 转换后相等。=== 同时比较类型和值，不做转换。=== 不比较引用地址（对象才比引用），也不涉及字符串排序或 NaN 忽略。

234. 在一个已按升序排好序的数组中查找目标值，数据量很大且查询频繁，相比顺序查找，二分查找的主要优势是？
  A. 每次比较都能排除一半区间
  B. 不需要数组有序即可使用
  C. 最坏情况比较次数与元素个数相同
  D. 可以在链表上直接使用
  答案：A
  解析：知识点：二分查找原理。正确项对，二分每次将候选区间减半，时间复杂度 O(log n)。二分依赖有序数组，最坏比较次数远小于 n，且链表不支持随机访问，不能直接套用。

235. 在关系型数据库中，某查询语句在 WHERE 条件中对索引列使用函数，如 WHERE DATE(create_time)='2024-01-01'，导致查询变慢，主要原因是？
  A. 函数使索引无法被有效利用
  B. DATE 函数本身执行很慢
  C. create_time 字段类型错误
  D. WHERE 子句不支持函数
  答案：A
  解析：知识点：索引失效场景。正确项对，对索引列施加函数会使索引无法按原值匹配，通常改为范围条件。DATE 函数执行开销不是主因，字段类型与 WHERE 支持函数都不成立。

236. 某后端接口在高并发下偶发返回旧数据，排查发现缓存更新采用先更新数据库再删除缓存，但删除操作在事务提交前执行，最恰当的改进是
  A. 把删除缓存改为先删缓存再更新数据库
  B. 将删除缓存操作放到数据库事务提交成功之后
  C. 把缓存过期时间调大到一天
  D. 对读请求加分布式锁并关闭缓存
  答案：B
  解析：知识点是缓存与数据库一致性时序。正确项：删除动作需在事务提交后进行，避免提交前删缓存后又被旧值回填。错误项：先删缓存再更新数据库仍可能在并发读时回填旧值；调大过期时间只会延长不一致窗口；关闭缓存并加锁代价过高且改变架构。

237. 某前端页面中按钮点击事件绑定在父容器上，点击子元素时事件先由父容器捕获再传到子元素，这种传播阶段称为
  A. 冒泡阶段
  B. 捕获阶段
  C. 目标阶段
  D. 委托阶段
  答案：B
  解析：知识点是DOM事件传播三阶段。正确项：从根到目标的方向是捕获阶段。错误项：冒泡是从目标向上；目标阶段指事件到达目标本身；委托是利用冒泡的编程手法而非传播阶段。

238. 对有序数组使用二分查找时，循环条件写成 while (low < high) 且更新为 low = mid + 1、high = mid，这种写法对区间含义的约定是
  A. 左闭右闭区间
  B. 左闭右开区间
  C. 左开右闭区间
  D. 双开区间
  答案：B
  解析：知识点是二分查找边界约定。正确项：high取mid且不包含high，说明区间为[low, high)。错误项：左闭右闭需要high=mid-1；左开右闭与双开均不符合该更新方式。

239. Git 中已经提交到本地仓库但尚未推送到远程，此时执行 git reset --soft HEAD~1 的效果是
  A. 撤销提交且改动进入暂存区
  B. 撤销提交且改动保留在工作区
  C. 撤销提交并丢弃全部改动
  D. 仅修改提交信息不改变内容
  答案：A
  解析：知识点是git reset三种模式差异。正确项：--soft只移动HEAD，原提交内容保留在暂存区。错误项：改动保留工作区是--mixed；丢弃改动是--hard；仅改信息应使用commit --amend。

240. 在TCP三次握手中，客户端收到服务器对SYN的确认后发送的第三个报文，其标志位通常是
  A. 仅SYN置位
  B. ACK置位
  C. FIN置位
  D. RST置位
  答案：B
  解析：知识点是TCP三次握手报文标志。正确项：第三步是客户端对服务器SYN的确认，ACK置位。错误项：SYN用于前两步建立方向；FIN用于断开；RST用于异常复位。

241. 某函数需要返回多个值，在Go语言中较符合惯例的做法是
  A. 返回一个包含所有值的切片
  B. 返回多个具名返回值
  C. 通过全局变量传出
  D. 返回格式化后的字符串
  答案：B
  解析：知识点是Go多返回值惯例。正确项：Go原生支持多返回值，可具名返回。错误项：切片丢失类型信息；全局变量破坏封装；字符串需解析且易错。

242. 在代码调试过程中，以下哪些做法有助于定位偶发空指针异常
  A. 在可能为空的变量使用前添加日志输出其引用
  B. 复现时开启断点并检查调用栈
  C. 把异常捕获后直接忽略继续运行
  D. 对关键对象增加非空断言并记录堆栈
  E. 将日志级别调为ERROR以减少输出
  答案：A、B、D
  解析：知识点是空指针异常调试手段。正确项：日志、断点调用栈、非空断言加堆栈都能帮助定位来源。错误项：忽略异常会掩盖问题；只保留ERROR会丢失定位所需的上下文日志。

243. 在Java中，关于String与StringBuilder的拼接操作，下列描述成立的是
  A. String每次拼接都新建对象，StringBuilder在自身缓冲区内追加
  B. String拼接会被编译器优化为StringBuilder，故两者运行期完全等价
  C. StringBuilder线程安全，String拼接线程不安全
  D. String不可变，所以其拼接结果无法被再次引用
  答案：A
  解析：知识点是字符串可变性：String不可变，每次拼接产生新对象；StringBuilder在缓冲区追加，适合循环拼接。选项说两者运行期完全等价，忽略了循环中的反复建对象；说StringBuilder线程安全错误，安全的是StringBuffer；说String结果无法再次引用违背引用语义。

244. TCP三次握手中，客户端收到服务器SYN+ACK后发送的报文段其ACK标志与序号含义是
  A. 确认服务器SYN，序号为客户端初始序号加1
  B. 确认服务器SYN，序号为服务器初始序号加1
  C. 请求建立连接，序号为服务器初始序号
  D. 请求建立连接，序号为客户端初始序号
  答案：A
  解析：知识点是三次握手报文语义：第三次握手确认服务器SYN，序号为客户端的初始序号加1；说序号为服务器初始序号加1是把确认号与序号混淆；说“请求建立连接”错误，第三次是确认而非请求；说序号为客户端初始序号忽略了SYN占一个序号。

245. 在关系数据库中，事务的隔离性主要解决的问题是
  A. 并发事务之间相互干扰导致数据不一致
  B. 事务执行中途系统崩溃导致数据丢失
  C. 事务提交后数据永久保存
  D. 事务操作的原子提交或回滚
  答案：A
  解析：知识点是ACID：隔离性约束并发事务的可见性，防止脏读、不可重复读、幻读；系统崩溃导致丢失属于持久性；提交后永久保存也是持久性；原子提交或回滚属于原子性。

246. 某后端接口在压测中出现大量TIME_WAIT连接，最可能的原因是
  A. 服务端主动关闭连接且并发短连接过多
  B. 客户端主动关闭连接且并发短连接过多
  C. 服务端监听队列过短导致连接被拒
  D. 客户端发送窗口过小导致吞吐下降
  答案：A
  解析：知识点是TCP状态归属：TIME_WAIT出现在主动关闭方，服务端大量出现说明服务端主动关闭短连接；客户端主动关闭时TIME_WAIT应在客户端；监听队列过短表现为连接被拒；发送窗口过小表现为吞吐下降而非TIME_WAIT堆积。

247. 对数组 [3, 1, 4, 1, 5] 执行一次冒泡排序（按升序，从前往后比较交换）后的结果是
  A. [1, 3, 1, 4, 5]
  B. [1, 1, 3, 4, 5]
  C. [3, 1, 4, 1, 5]
  D. [1, 3, 4, 1, 5]
  答案：A
  解析：知识点是冒泡排序单趟过程：依次比较(3,1)交换、(3,4)不换、(4,1)交换、(4,5)不换，得[1,3,1,4,5]；[1,1,3,4,5]是完全排好后的结果；原数组说明未发生交换；[1,3,4,1,5]漏掉了4与1的交换。

248. 在 MySQL 中，对 InnoDB 表执行 SELECT ... FOR UPDATE 时，若查询条件走的是唯一索引等值查询且命中记录，该语句通常
  A. 对命中行加排他锁
  B. 对整个表加共享锁
  C. 对命中行加共享锁
  D. 不加任何锁
  答案：A
  解析：知识点是 InnoDB 行锁与 FOR UPDATE 语义。FOR UPDATE 对命中记录加排他锁以支持后续更新；选项整表共享锁是 LOCK TABLES READ 的效果；选项对命中行加共享锁是 LOCK IN SHARE MODE 的行为；选项不加锁与 FOR UPDATE 定义矛盾。

249. 在 Python 中，以下代码执行后 lst 的值是 lst=[1,2,3]; lst[1:2]=[9,8,7]
  A. [1,9,8,7,3]
  B. [1,9,2,3]
  C. [1,9,8,7,2,3]
  D. [1,2,9,8,7,3]
  答案：A
  解析：知识点是切片赋值的替换语义。lst[1:2] 表示下标 1 到 2 前一个元素即 [2]，用 [9,8,7] 整体替换该区间得到 [1,9,8,7,3]；选项相当于只替换一个元素为 9；选项把原第 2 个元素保留在中间；选项把插入位置当成下标 2 起。

250. TCP 三次握手中，客户端收到服务器对 SYN 的确认后发送的报文段中，ACK 标志与序号的关系是
  A. ACK 置 1，确认号为服务器初始序号加 1
  B. ACK 置 0，序号为客户端初始序号加 1
  C. ACK 置 1，确认号为客户端初始序号加 1
  D. ACK 置 1，序号为服务器初始序号加 1
  答案：A
  解析：知识点是 TCP 连接建立流程。第三次握手客户端确认服务器 SYN，确认号应为服务器初始序号加 1，ACK 置 1；选项 ACK 置 0 不符合确认语义；选项把确认对象弄成客户端自己的序号；选项把序号与确认号混淆。

251. 在C语言中，表达式 sizeof(char) + sizeof(int) 在常见32位平台上求值后通常得到的结果是
  A. 2
  B. 4
  C. 5
  D. 8
  答案：C
  解析：知识点是sizeof运算符返回类型占字节数。char占1字节、int占4字节，相加为5，故C正确；A把int当1字节；B只算int；D把char当4字节或误算为两倍int。

252. Python中执行 list = [1,2,3]; list.append([4,5]) 后，len(list) 的值是
  A. 3
  B. 4
  C. 5
  D. 6
  答案：B
  解析：append把整个列表[4,5]作为单个元素加入，原列表变为[1,2,3,[4,5]]，长度为4，B正确；A忽略追加；C误用extend语义；D把嵌套元素展开计数。

253. Java中 String s = "a"; s = s + "b"; 执行后关于字符串对象数量的说法，正确的是
  A. 只创建了1个String对象
  B. 创建了2个String对象，s指向新的那个
  C. 创建了2个String对象，s仍指向最初那个
  D. 创建了3个String对象，其中1个被回收
  答案：B
  解析：字符串不可变，拼接会生成新对象，s重新指向新对象，故共2个对象，B正确；A忽略不可变性；C说s指旧对象；D凭空多算对象数。

254. Python中函数内部要对全局变量 count 重新赋值，应使用的声明是
  A. global count
  B. nonlocal count
  C. static count
  D. extern count
  答案：A
  解析：global声明使函数内赋值作用于模块级变量，A正确；B用于嵌套函数的外层局部变量；C、D不是Python关键字。

255. 关于HTTP状态码，表示请求的资源已被永久移动到新位置的是
  A. 301
  B. 302
  C. 304
  D. 404
  答案：A
  解析：301 Moved Permanently表示永久重定向，A正确；302是临时重定向；304是缓存未修改；404是资源不存在。

256. 对链表和数组在头部插入元素的效率进行比较，通常更优的是
  A. 数组，因为支持随机访问
  B. 链表，因为只需修改指针
  C. 数组，因为内存连续
  D. 链表，因为需要遍历到尾部
  答案：B
  解析：链表头部插入只需调整指针，O(1)，B正确；A随机访问与插入效率无关；C连续内存不提升头部插入；D描述的是尾部插入的缺点。

257. 关于Python中列表切片 lst[1:4] 的行为，下列描述准确的是
  A. 包含下标1、2、3、4的元素
  B. 包含下标1、2、3的元素
  C. 包含下标0到4共5个元素
  D. 包含下标1到末尾的所有元素
  答案：B
  解析：知识点是Python切片左闭右开。lst[1:4]取下标1、2、3，不含4。选项0把右端当闭区间多取了下标4；选项2错在起点应为1而非0；选项3错在省略结束索引才取到末尾。

258. 在Java中，String s = "a" + "b" + "c" 编译后参与拼接的字符串常量会在何时被合并
  A. 运行时每次执行到该语句时
  B. 编译期由编译器合并为一个常量
  C. 类加载时由类加载器合并
  D. 第一次调用intern方法时合并
  答案：B
  解析：知识点是Java常量折叠。纯字面量拼接在编译期就合并为"abc"。选项0误以为每次运行都重新拼接；选项2把编译期优化错归到类加载阶段；选项3把运行时常量池intern机制误当成拼接时机。

259. 关于HTTP状态码，客户端请求的资源需要身份认证且未提供凭证时，服务器应返回
  A. 301
  B. 401
  C. 403
  D. 404
  答案：B
  解析：知识点是HTTP状态码语义。401表示未认证，需提供凭证。选项0是永久重定向；选项2表示已认证但无权限；选项3表示资源不存在。

260. 下列排序算法中，在最坏情况下时间复杂度仍为 O(n log n) 的是
  A. 快速排序
  B. 归并排序
  C. 插入排序
  D. 冒泡排序
  答案：B
  解析：知识点是排序算法最坏复杂度。归并排序任何情况都是O(n log n)。选项0快排最坏为O(n²)；选项2插入排序最坏O(n²)；选项3冒泡排序最坏O(n²)。

261. 某后端接口在高并发下偶发返回旧数据，排查发现读请求走了从库而写请求走主库，且主从复制存在延迟，正确的处置思路是
  A. 把所有读请求强制路由到主库
  B. 在写后短时间内将该用户读请求路由到主库
  C. 增大从库连接池并缩短超时时间
  D. 对从库查询结果增加本地缓存
  答案：B
  解析：知识点是主从延迟下的读写一致性。写后短时间读主库可保证读己之写。选项0全走主库会失去读写分离意义并压垮主库；选项2连接池与超时不影响复制延迟；选项3缓存旧数据会加重不一致。

262. 在 SQL 中，若要查询 employees 表中每个部门人数且只显示人数大于 5 的部门，正确写法是
  A. SELECT dept, COUNT(*) FROM employees WHERE COUNT(*) > 5 GROUP BY dept
  B. SELECT dept, COUNT(*) FROM employees GROUP BY dept HAVING COUNT(*) > 5
  C. SELECT dept, COUNT(*) FROM employees GROUP BY dept WHERE COUNT(*) > 5
  D. SELECT dept, COUNT(*) FROM employees HAVING COUNT(*) > 5 GROUP BY dept
  答案：B
  解析：知识点是 WHERE 与 HAVING 的区别。聚合结果过滤须用 HAVING 且置于 GROUP BY 之后。选项 A 在 WHERE 中用聚合函数非法；选项 C 把 WHERE 放到 GROUP BY 之后语法错误；选项 D 缺少 GROUP BY 且 HAVING 位置错误。

263. Python 中执行 def f(x, lst=[]): lst.append(x); return lst 后，连续调用 f(1) 与 f(2) 的返回值分别是
  A. [1] 和 [2]
  B. [1] 和 [1,2]
  C. [2] 和 [1,2]
  D. [1,2] 和 [1,2]
  答案：B
  解析：知识点是可变默认参数的共享特性。默认列表在函数定义时创建并跨调用复用，故第一次返回 [1]，第二次在同一列表追加得 [1,2]。选项 A 误以为每次重新创建；选项 C 误把首次追加算成 2；选项 D 误以为首次即返回两个元素。

264. 在 Git 中，已提交到本地仓库但尚未推送到远程，此时想撤销最近一次提交并保留改动在工作区，应使用
  A. git reset --soft HEAD~1
  B. git reset --hard HEAD~1
  C. git revert HEAD
  D. git checkout HEAD~1
  答案：A
  解析：知识点是 reset 三种模式差异。--soft 只移动 HEAD，改动保留在暂存区与工作区。选项 B 的 --hard 会丢弃改动；选项 C 的 revert 会生成反向提交而非撤销提交本身；选项 D 的 checkout 会切到旧提交形成分离头指针，不达目的。

265. 在多线程环境中对共享计数器 count 执行 count++ 出现丢失更新，最合适的修复方式是
  A. 把 count 声明为 volatile
  B. 用 synchronized 或原子类保护自增
  C. 把 count 改为 long 类型
  D. 在自增前后各加一次 Thread.yield
  答案：B
  解析：知识点是复合操作的原子性。count++ 含读改写三步，须用锁或原子类保证原子。选项 A 的 volatile 只保证可见性不保证原子；选项 C 改变类型不解决竞态；选项 D 的 yield 反而可能加剧交错，不能保证正确。

266. 关于 TCP 三次握手，客户端发送 SYN 后收到服务器 SYN+ACK，此时客户端进入的状态是
  A. ESTABLISHED
  B. SYN_SENT
  C. SYN_RCVD
  D. CLOSE_WAIT
  答案：C
  解析：知识点是 TCP 连接建立状态机。收到 SYN+ACK 后客户端进入 SYN_RCVD 并回复 ACK。选项 A 是发出最终 ACK 后的状态；选项 B 是发出 SYN 后等待的状态；选项 D 是关闭流程中被动方收到 FIN 后的状态。

267. 在Java中，下列关于String与StringBuilder的描述正确的是
  A. StringBuilder的内容可变且拼接效率通常高于String
  B. String的内容可变且拼接效率通常高于StringBuilder
  C. String与StringBuilder的内容都不可变
  D. StringBuilder的内容不可变但拼接效率高于String
  答案：A
  解析：String对象不可变，每次拼接都会产生新对象；StringBuilder内部维护可变字符数组，适合频繁拼接。选项B把两者特性说反；选项C错误，StringBuilder可变；选项D错误，StringBuilder内容可变而String不可变。

268. 在HTTP协议中，状态码401与403的区别是
  A. 401表示未认证，403表示已认证但无权限
  B. 401表示无权限，403表示未认证
  C. 401表示服务器错误，403表示客户端错误
  D. 401表示资源不存在，403表示请求方法不允许
  答案：A
  解析：401 Unauthorized表示请求缺少有效身份凭证；403 Forbidden表示身份已识别但被拒绝访问。选项B把两者语义对调；选项C混淆了5xx与4xx；选项D把404与405的含义套用到了401和403上。

269. 下列排序算法中，属于稳定排序的是
  A. 归并排序
  B. 快速排序
  C. 堆排序
  D. 希尔排序
  答案：A
  解析：归并排序在合并时保持相等元素的原有相对次序，是稳定排序。快速排序、堆排序、希尔排序在典型实现中都会因跨距离交换而破坏稳定性。

270. 前端页面出现样式错乱，排查发现某元素设置了float:left但父容器高度塌陷，下列处置中最恰当的是
  A. 给父容器添加overflow:hidden以触发BFC
  B. 给该元素添加display:inline
  C. 给父容器设置position:absolute
  D. 删除该元素的float属性并改用table布局
  答案：A
  解析：父容器高度塌陷是浮动元素脱离常规流所致，添加overflow:hidden可触发BFC包裹浮动。选项B不解决父容器塌陷；选项C使父容器脱离常规流并改变布局；选项D改用table属于过度改造且不针对根因。

271. 在关系数据库中，若要保证一个事务的修改在提交前不被其他事务看到，应设置的隔离级别是
  A. 读已提交
  B. 读未提交
  C. 可重复读
  D. 串行化
  答案：A
  解析：知识点为事务隔离级别。读已提交保证只能读到已提交数据，未提交修改不可见，故a项正确。读未提交会读到未提交数据；可重复读主要保证同一事务内多次读一致；串行化虽也满足但级别更高且并非题目所问的最低保证级别。

272. 对栈依次执行push(1)、push(2)、pop()、push(3)、pop()，最终栈顶元素是
  A. 1
  B. 2
  C. 3
  D. 空
  答案：A
  解析：知识点为栈的后进先出特性。push1、push2后栈为[1,2]，pop弹出2，push3后栈为[1,3]，再pop弹出3，栈顶为1，故a项正确。b项2已被弹出；c项3也已被弹出；d项栈中仍有元素1。

273. 在TCP三次握手中，客户端收到服务器SYN+ACK后发送的报文段中，ACK标志位和确认号的含义是
  A. 确认收到服务器SYN，确认号为服务器初始序号加1
  B. 请求建立连接，确认号为客户端初始序号
  C. 通知服务器断开连接，确认号为客户序号加1
  D. 重传客户端SYN，确认号保持不变
  答案：A
  解析：知识点为TCP三次握手。第三次握手客户端发送ACK，确认服务器SYN，确认号应为服务器初始序号加1，故a项正确。b项把第三次握手当成首次请求；c项混淆了断开流程；d项误判为重传且确认号不变。

274. 在编写健壮的后端接口时，下列做法中能有效提升异常可观测性的有
  A. 记录异常堆栈并附带请求标识
  B. 对可预期业务异常返回统一错误码
  C. 捕获异常后仅打印“出错了”
  D. 用空catch块忽略异常
  E. 将异常信息直接透传给前端
  答案：A、B
  解析：知识点为异常处理与日志可观测性。记录堆栈与请求标识便于定位，统一错误码便于前端处理，a、b正确。c项信息量不足无法排障；d项忽略异常会掩盖问题；e项向前端透传内部异常可能泄露实现细节且不安全。

275. 在二叉搜索树中查找一个不存在的值，最坏情况下比较次数与什么成正比
  A. 树的高度
  B. 节点总数
  C. 叶子节点数
  D. 树的度数
  答案：A
  解析：知识点是BST查找复杂度。查找路径从根到叶，最坏比较次数等于树高；选项1节点总数是最坏遍历的规模但非查找比较次数；选项2、3与查找路径无关。

276. Java中 String s1="abc"; String s2=new String("abc"); 则 s1==s2 的结果是
  A. false
  B. true
  C. 编译错误
  D. 运行时异常
  答案：A
  解析：知识点是字符串常量池与对象引用比较。s1指向常量池，s2在堆上新对象，==比较引用地址故为false；选项1误以为内容相同引用就相同；选项2、3与语法无关。

277. 以下关于TCP与UDP的描述中，正确的有
  A. TCP提供面向连接的可靠传输
  B. UDP头部开销比TCP小
  C. TCP通过三次握手建立连接
  D. UDP在传输层提供拥塞控制
  E. TCP不保证数据顺序
  答案：A、B、C
  解析：知识点是传输层协议特性。TCP面向连接、可靠、三次握手、保证顺序；UDP头部小、无连接、不保证可靠与顺序，拥塞控制由应用或上层处理。选项3错误，UDP本身不提供拥塞控制；选项4错误，TCP保证顺序。

278. Python中，表达式 [x for x in range(3) for y in range(2)] 生成的列表长度是
  A. 3
  B. 5
  C. 6
  D. 8
  答案：C
  解析：知识点是列表推导式多重for的笛卡尔积展开。外层x取3个值，内层y取2个值，共3×2=6个元素。选项3只算了外层，选项5把两层相加，选项8误用2的3次方。

279. 关于HTTP状态码，客户端请求的资源在服务器上不存在时返回的是
  A. 200
  B. 301
  C. 404
  D. 500
  答案：C
  解析：知识点是HTTP状态码语义。404 Not Found表示资源不存在。200表示成功，301表示永久重定向，500表示服务器内部错误。

280. 在关系数据库中，若表R有外键引用表S的主键，则向R插入元组时数据库通常
  A. 不检查S中是否存在对应值
  B. 检查S中是否存在被引用的值
  C. 自动删除S中的对应行
  D. 自动把R的主键改为外键值
  答案：B
  解析：知识点是外键的参照完整性约束。插入R时须保证外键值在S中存在或为NULL，否则违反约束。选项不检查违反外键定义，自动删除S行属于级联删除的方向错误，自动改主键不符合外键语义。

281. 某后端接口上线后偶发超时，日志显示数据库连接池活跃连接数持续等于最大连接数，此时首先应排查的环节是
  A. 前端静态资源是否过大
  B. 是否存在未释放的数据库连接
  C. 服务器网卡是否千兆
  D. 浏览器缓存是否开启
  答案：B
  解析：知识点是连接池耗尽类故障定位。活跃连接数持续等于上限说明连接被占满，常见原因是代码中连接未关闭或长事务。前端静态资源、网卡速率、浏览器缓存与该现象无直接因果关系。

282. 前端开发中，给按钮绑定点击事件后又调用了 event.preventDefault()，其作用是
  A. 阻止事件继续冒泡到父元素
  B. 取消事件的默认行为
  C. 移除该元素上的点击监听
  D. 阻止后续同级监听器执行
  答案：B
  解析：知识点：DOM 事件模型。preventDefault 取消元素默认行为，如链接跳转或表单提交。阻止冒泡应使用 stopPropagation；移除监听应使用 removeEventListener；阻止同级后续监听应使用 stopImmediatePropagation。

283. 下列排序算法中，平均时间复杂度为 O(n log n) 且稳定的是
  A. 快速排序
  B. 堆排序
  C. 归并排序
  D. 选择排序
  答案：C
  解析：知识点：排序算法复杂度与稳定性。归并排序平均 O(n log n) 且相等元素相对次序不变，是稳定排序。快速排序与堆排序平均 O(n log n) 但不稳定；选择排序平均 O(n^2) 且不稳定。

284. 在 Git 中，想把已经提交到本地仓库但尚未推送到远程的最新一次提交撤销并保留改动在工作区，应使用
  A. git reset --soft HEAD~1
  B. git reset --mixed HEAD~1
  C. git reset --hard HEAD~1
  D. git revert HEAD
  答案：B
  解析：知识点：Git reset 三种模式。--mixed 是默认模式，撤销提交并把改动放回工作区（同时取消暂存）。--soft 会把改动留在暂存区；--hard 会丢弃改动；git revert 是生成一次新提交来抵消，不撤销历史。

285. 在 REST 接口设计中，客户端要部分更新已有资源，通常应使用的方法是
  A. GET
  B. PUT
  C. PATCH
  D. HEAD
  答案：C
  解析：知识点：HTTP 方法与资源操作语义。PATCH 用于对资源进行部分更新。GET 只读取；PUT 多用于整体替换；HEAD 只取响应头，不修改资源。

286. 某后端服务上线后出现 CPU 持续接近 100% 且接口响应变慢，日志显示同一查询被高频重复执行，作为程序员首先应排查的环节是
  A. 数据库连接池最大连接数是否设置过小
  B. 该查询是否缺少缓存或存在循环内查询
  C. 前端是否开启了浏览器缓存
  D. 服务器磁盘剩余空间是否不足
  答案：B
  解析：知识点：性能问题定位与常见 N+1/重复查询。日志显示同一查询高频重复，优先怀疑缺少缓存或在循环中反复查库。连接池过小通常表现为等待连接；前端缓存与磁盘空间一般不会直接导致这种高频重复查询。

287. Python 中 `[[]]*3` 创建一个含三个元素的列表后，对第一个子列表执行 append(1)，此时该列表的内容是什么
  A. [[1], [], []]
  B. [[1], [1], [1]]
  C. [[], [], []]
  D. [[1, 1, 1]]
  答案：B
  解析：知识点是 Python 序列乘法对可变对象的引用复制语义。正确项：`[[]]*3` 复制的是同一个内层列表的引用，修改任一项都会同步体现，故三个子列表都变成 [1]。错误项：[[1],[],[]] 误以为复制产生独立副本；[[],[],[]] 误以为 append 作用于临时对象；[[1,1,1]] 误以为三个 1 被合并进同一层。

288. HTML 中要让一个块级元素的宽度包含其 padding 和 border，应设置 box-sizing 为哪个值
  A. content-box
  B. border-box
  C. padding-box
  D. margin-box
  答案：B
  解析：知识点是 CSS 盒模型与 box-sizing。正确项：border-box 使 width 涵盖 content、padding、border，便于布局计算。错误项：content-box 是默认值，width 只含内容区；padding-box 不是标准关键字；margin-box 并非合法取值。

289. 在一个已按升序排好序的数组中用二分查找定位目标值，当中间元素小于目标值时，下一步应如何调整查找区间
  A. 把左边界移到中间位置加一
  B. 把右边界移到中间位置减一
  C. 把左右边界都移到中间位置
  D. 把左边界移到中间位置减一
  答案：A
  解析：知识点是二分查找的区间收缩方向。正确项：中间元素小于目标说明目标只可能在右半区，故左边界取 mid+1。错误项：右边界减一用于中间元素大于目标的情形；同时移动两端会跳过候选；左边界减一会把已排除的 mid 重新纳入并可能死循环。

290. Java 中 String 类型的变量作为 HashMap 的键时能够正确工作，最根本的原因是 String 具备什么特性
  A. String 是不可变类且正确重写了 equals 与 hashCode
  B. String 由 JVM 特殊分配在常量池中
  C. String 实现了 Comparable 接口
  D. String 的 length 方法返回字符个数
  答案：A
  解析：知识点是哈希容器对键的要求。正确项：不可变保证哈希值稳定，正确重写 equals 与 hashCode 才能定位和判等。错误项：常量池只影响字面量复用，不影响哈希查找正确性；Comparable 用于排序，与哈希定位无关；length 与哈希行为无关。

291. Python 中用 requests 库请求一个返回 JSON 的接口，取回响应后解析为字典最直接的做法是哪一项
  A. json.loads(response.text)
  B. response.json()
  C. eval(response.text)
  D. response.content.decode()
  答案：B
  解析：知识点是 requests 响应对象的 JSON 解析。正确项：response.json() 内部按响应声明的编码解析并返回 Python 对象。错误项：json.loads 也可行但需自行处理编码，不如 json() 直接；eval 有执行任意代码的安全风险；content.decode() 只得到字符串，未完成解析。

292. 在一个电商下单接口中，若扣减库存成功但创建订单记录时抛异常，为保证数据一致，正确的处置步骤是哪一项
  A. 捕获异常后回滚库存并向上返回失败
  B. 忽略异常让库存保持扣减状态
  C. 先返回成功再异步补建订单记录
  D. 重新扣减一次库存以覆盖异常
  答案：A
  解析：知识点是事务边界与失败补偿。正确项：两步骤须在同一事务中，创建订单失败时回滚库存并返回失败，避免少卖。错误项：保持扣减会造成库存凭空减少；先成功再异步补单无法保证最终一致且用户体验错误；重复扣减会进一步放大数据错误。

293. 用 Python 编写函数统计字符串中每个字符出现次数时，若要求统计结果不受字符输入顺序影响，最合适的中间数据结构是
  A. 字典，以字符为键、次数为值
  B. 列表，按字符出现顺序追加
  C. 集合，只记录出现过的字符
  D. 元组，把字符和次数成对保存
  答案：A
  解析：知识点是哈希表在计数场景中的应用。字典以字符为键可直接累加次数，天然与输入顺序无关。列表按顺序追加，顺序不同结果不同。集合只记录是否出现，无法保存次数。元组不可变，无法边遍历边累加计数。

294. 在 Java 中，父类引用指向子类对象后调用被子类重写的方法，实际执行的是子类实现，这一现象称为
  A. 动态绑定
  B. 静态绑定
  C. 方法隐藏
  D. 方法重载
  答案：A
  解析：知识点是面向对象多态的运行期方法分派。父类引用调用被重写方法，运行时按实际对象类型选择子类实现，即动态绑定。静态绑定在编译期确定，不适用于重写方法。方法隐藏针对静态方法或字段，不体现运行期多态。方法重载是同类中同名不同参，与父类引用调用子类实现无关。

295. 用快速排序对含大量重复元素的数组排序时，若分区函数始终以最左元素为基准且把等于基准的元素全部分到一侧，最可能导致的结果是
  A. 递归深度接近 n，时间复杂度退化为 O(n²)
  B. 每次分区后两侧规模严格相等，复杂度保持 O(n log n)
  C. 重复元素被自动去重，排序结果元素个数减少
  D. 基准元素被交换到末尾，后续不再参与分区
  答案：A
  解析：知识点是快速排序在重复元素与劣质基准下的退化。等于基准的元素全挤到一侧会使子问题规模每次只减一，递归深度接近 n，退化为 O(n²)。两侧严格相等需要基准接近中位数并均衡划分，本题条件不满足。快速排序不会去重。基准被交换到末尾并不会使它退出后续递归，递归仍会覆盖到它所在的子区间。

296. 在 Git 中，已经执行 git add 把修改放入暂存区，随后发现其中某个文件不该提交，希望把它从暂存区撤出但保留工作区改动，应使用
  A. git restore --staged 该文件
  B. git restore 该文件
  C. git reset --hard 该文件
  D. git checkout -- 该文件
  答案：A
  解析：知识点是暂存区与工作区的撤销操作区别。git restore --staged 只把文件从暂存区移回未暂存状态，工作区改动保留。git restore 该文件会用版本库内容覆盖工作区，改动丢失。git reset --hard 会同时重置暂存区和工作区，改动丢失。git checkout -- 该文件同样用版本库版本覆盖工作区，改动丢失。

297. 某后端接口线上偶发超时，日志显示数据库连接池等待时间陡增而慢查询很少，排查时最应优先确认的是
  A. 连接池最大连接数是否被长时间占用未归还
  B. 数据库服务器磁盘是否即将写满
  C. 接口返回的 JSON 字段是否过多
  D. 前端是否开启了浏览器缓存
  答案：A
  解析：知识点是连接池耗尽导致等待的典型故障模式。等待时间陡增而慢查询少，常见原因是连接被借出后未及时归还，故应优先查最大连接数与占用归还。磁盘写满通常伴随写入报错或慢查询增多，与本题现象不符。JSON 字段多影响序列化，不直接造成连接池等待。浏览器缓存属于前端范畴，与后端连接池无关。

298. 在编写涉及共享可变状态的并发程序时，下列做法中能降低数据竞争风险的有
  A. 对共享变量的读改写使用原子操作或加锁保护
  B. 把共享状态改为线程内局部变量后再汇总
  C. 使用不可变对象在多个线程间传递数据
  D. 依靠调整线程优先级来避免同时访问
  E. 在循环中反复读写共享变量以减少锁次数
  答案：A、B、C
  解析：知识点是并发编程中避免数据竞争的手段。原子操作或加锁可保证读改写的整体性，降低竞争。把共享状态局部化后汇总，减少了共享访问。不可变对象发布后不会被修改，天然线程安全。线程优先级不提供互斥保证，不能避免同时访问。循环中反复读写共享变量反而增加竞争窗口，且减少锁次数不等于消除竞争。

299. 在Java中，以下关于String与StringBuilder拼接字符串的描述，正确的是哪一项？
  A. String用+拼接时每次都会创建新对象，循环内拼接大量字符串时StringBuilder更合适
  B. StringBuilder用+拼接时会自动转为String，因此循环内拼接大量字符串时两者性能相同
  C. String是不可变类，StringBuilder也是不可变类，两者都适合在循环内直接拼接
  D. String用concat拼接时不会创建新对象，因此循环内拼接大量字符串时String更合适
  答案：A
  解析：知识点：Java字符串不可变性与StringBuilder的可变字符序列。String的+拼接在循环中会产生大量中间String对象，开销大，StringBuilder在单线程循环拼接场景更合适，故A正确。B错在StringBuilder不支持+拼接，且性能不会相同。C错在StringBuilder是可变类。D错在String.concat同样会返回新String对象，不会原地修改。

300. 某后端接口在压测时出现响应时间随并发上升而急剧恶化，日志显示大量线程阻塞在数据库连接获取处，以下哪些处置措施是合理的？
  A. 检查连接池最大连接数与数据库最大连接数是否匹配，并适当调整
  B. 在获取连接超时后直接无限重试，直到拿到连接为止
  C. 对慢SQL进行定位与优化，减少单个请求占用连接的时间
  D. 把连接池最大连接数设置为远大于数据库承受能力以消除等待
  答案：A、C
  解析：知识点：数据库连接池容量规划与慢查询治理。A合理，连接池上限与数据库承载能力需匹配；C合理，缩短单请求持连时间能缓解阻塞。B错在无限重试会放大阻塞并可能拖垮数据库。D错在连接数超过数据库承载能力会导致数据库侧资源耗尽，反而更慢或报错。