【面试题】笔试综合1-CSDN博客

本文链接：https://blog.csdn.net/wamp0001/article/details/148960802

1.完成在双向循环链表结点 p 之后插入 s 的操作是（）。

A. p->next=s;s->prior=p;p->next->prior=s;s->next=p->next

B. p->next->prior=s;p->next=s;s->prior=p;s->next=p->next

C. s->prior=p;s->next=p->next;p->next=s;p->next->prior=s

D. s->prior=p;s->next=p->next;p->next->prior=s;p->next=s

正确答案：D

解题分析：考察方向链表。

我们要完成的是：在节点 p 后插入新节点 s

双向链表中每个节点都有两个指针：

next：指向下一个节点
prior：指向前一个节点

插入操作的关键在于 顺序正确地修改四个指针：

s->next → 指向 p 原来的后继
s->prior → 指向 p
p->next → 指向 s
p->next->prior（原后继）→ 指向 s

✅ 正确顺序（以 D 为例）：

s->prior = p;                // 1. s 的前驱是 p
s->next = p->next;           // 2. s 的后继是 p 的后继
p->next->prior = s;          // 3. p 的后继的前驱改为 s
p->next = s;                 // 4. p 的后继改为 s

✨ 总结口诀（记忆法）：

“先连自己，再连别人”

顺序：

设置 s 的前后指针
修改 p 和后继节点的指针

2、如果进程请求它必须等待的某些事件，则进程进入（）。

A.退出状态

B.阻塞状态

C.挂起状态

D.就绪状态

正确答案：B

本题考查点：操作系统。

分析：进程调度图如下：

3、下图描述了一种设计模式，该设计模式不可以（）

A.动态决定由一组对象中某个对象处理该请求

B.动态指定处理一个请求的对象集合, 并高效率地处理一个请求

C.使多个对象都有机会处理请求，避免请求的发送者和接收者间的耦合关系

D.将对象连成一条链，并沿着该链传递请求

【分析】：考查点：设计模式

上图是一个典型的责任链设计模式。

责任链模式是一种对象行为模式，它将多个对象连成一条链，并沿着该链传递请求，链路上的每一个对象都有机会处理这个请求，它提供了一种松耦合的机制。

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

因此答案为B。

4、设有以下宏定义：

#define N 3+1

#define Y(n) ((N+1)*n)

则执行语句 z=2*(N+Y(5+1))后，z 的值为（）。

A.60

B.190

C.248

D.上述答案都不对

【分析】知识点C++

这就是一个简单的计算题，把变量代入计算即可。

步骤	替换结果
原始	`2 * (N + Y(5 + 1))`
展开	`2 * (3+1 + ((3+1+1)*(5+1)))`
计算	`2 * (4 + (5 * 6)) = 2 * 34 = 68`

5、如下代码的结果是什么 ?

class Base {
    Base() {
        System.out.print("Base");
    }
}

public class Alpha extends Base {
    public static void main(String[] args) {
        new Alpha(); // 创建 Alpha 实例
        new Base();  // 创建 Base 实例
    }
}

A.Base

B.BaseBase

C.编译失败

D.代码运行但没有输出

E.运行时抛出异常

【分析】考查点java 程序运行，继承

🔹 1. 类继承关系：

Alpha 继承自 Base
所以创建 Alpha 对象时，先调用父类 Base 的构造函数

🔹 2. 构造函数调用顺序：

当你使用 new Alpha() 时：
- 首先自动调用父类 Base 的无参构造函数（隐式调用）
- 然后再执行 Alpha 自己的构造函数（虽然没有显式写出来）

注意：即使子类没有定义构造函数，Java 也会默认生成一个无参构造函数，并在其中隐式调用 super()。

🔍 详细执行流程：

运行 new Alpha()
- 隐式调用 super()，即 Base() 构造函数
- 输出：Base
- 然后执行 Alpha() 构造函数（无内容，不输出）
运行 new Base()
- 直接调用 Base() 构造函数
- 输出：Base

✅ 最终输出结果：

BaseBaseBaseBase

💡 补充说明：

如果你在 Alpha 类中添加构造函数，比如：
```
Alpha() {
    System.out.print("Alpha");
}
```
则输出会变成：
```
BaseAlphaBase
```

6、分析下面go 程序的运行结果：

package main
 
import (
    "fmt"
)
 
func main() {
    i := [3]int{10, 10, 10}
    j := []int(i[2:3])
    i[2] = 900
    fmt.Println(j[0])
}

A.0

B.10

C.900

D.编译错误

【分析】

分析步骤：

🔹 第一步：

i := [3]int{10, 10, 10}

定义了一个长度为 3 的数组 i，值是 {10, 10, 10}
数组是值类型，赋值时会拷贝整个数组

🔹 第二步：

j := []int(i[2:3])

i[2:3] 是对数组 i 的切片操作，取索引 [2, 3) 范围的元素（即只有 i[2]）
所以 i[2:3] 是一个切片，内容为 [10]
j 是一个新的切片，它引用的是 底层数组 i 的第 2 个元素

📌 切片是引用类型，指向底层数组的一段内存。

🔹 第三步：

i[2] = 900

修改数组 i 的第三个元素为 900
因为 j 引用了这个位置的元素，所以 j[0] 也会看到更新

🔹 第四步：

fmt.Println(j[0])

输出 j[0]，此时它的值就是 i[2] → 900

✅ 最终输出结果： 900

💡 补充说明：

i[2:3] 创建的是一个长度为 1、容量为 1 的切片（从索引 2 开始到数组末尾）
j 和 i 共享同一块内存区域，因此修改 i[2] 会影响 j[0]
如果你使用 j := i[2:3]，也可以达到相同效果，不需要强制转换 []int

7、下面关于Go语言中的map说法正确的是（）

A. map反序列化时json.unmarshal的入参必须为map的地址

B. 在函数调用中传递map，则子函数中对map元素的增加不会导致父函数中map的修改

C. 在函数调用中传递map，则子函数中对map元素的修改不会导致父函数中map的修改

D. 不能使用内置函数delete删除map的元素

【分析】知识点：golang map 特性

首先，回顾 Go 中 map 的基本特性：

Go 的 map 是 引用类型（reference type）

传递 map 给函数时，是 按值传递一个 map header 的副本

但这个 header 指向的是同一个底层哈希表

所以：对 map 元素的修改会反映到所有引用它的地方

✅ 看选项：

map反序列化时json.unmarshal的入参必须为map的地址

✔️ 正确！

var m map[string]string
json.Unmarshal(data, &m) // 必须传指针

json.Unmarshal 要求第二个参数是可写的（即是一个指针）
因为你需要让函数内部能修改你传入的变量（包括创建新的 map）

📌 所以该选项正确

在函数调用中传递map，则子函数中对map元素的增加不会导致父函数中map的修改

❌ 错误！

map 是引用类型
子函数中添加新键值对（如 m["a"] = "b"）会影响父函数中的 map

📌 所以该选项错误

在函数调用中传递map，则子函数中对map元素的修改不会导致父函数中map的修改

❌ 错误！

同上，map 是引用类型
修改 map 元素（如 m["key"] = newValue）会反映到父函数

📌 所以该选项错误

不能使用内置函数delete删除map的元素

❌ 错误！

Go 提供了内置函数 delete() 来删除 map 中的键：

m := map[string]int{"a": 1}
delete(m, "a") // 正确

📌 所以该选项错误

✅ 正确答案：A

8、以下关于Go的说法正确的是（）
1.Go支持运算符重载
2.Go函数可以返回多个值

A.只有1正确

B.只有2正确

C.1和2都正确

D.1和2都不正确

【分析】：答案B .