📋 试卷结构
| 部分 | 题型 | 题量 | 分值 |
|---|---|---|---|
| 第一部分 | C语言基础 | 35题 | 75分 |
| 第二部分 | C++核心特性 | 25题 | 50分 |
| 第三部分 | 数据结构与算法 | 20题 | 40分 |
| 第四部分 | Linux系统编程 | 15题 | 30分 |
| 第五部分 | 网络编程 | 10题 | 20分 |
| 第六部分 | 智力与逻辑 | 5题 | 10分 |
| 合计 | 110题 | 225分 |
详细题型分布
第一部分:C语言基础(35题,75分)
- 选择题:10题 × 2分 = 20分
- 填空题:2题 × 5分 = 10分
- 简答题:2题 × 5分 = 10分
- 编程题:1题 × 10分 = 10分
- 程序分析题:5题 × 3分 = 15分
- 判断题:10题 × 1分 = 10分
第二部分:C++核心特性(25题,50分))
- 选择题:10题 × 2分 = 20分
- 填空题:2题 × 5分 = 10分
- 简答题:2题 × 5分 = 10分
- 编程题:1题 × 10分 = 10分
第三部分:数据结构与算法(20题,40分)
- 选择题:10题 × 2分 = 20分
- 简答题:2题 × 5分 = 10分
- 编程题:1题 × 10分 = 10分
第四部分:Linux系统编程(15题,30分)
- 选择题:6题 × 2分 = 12分
- 简答题:3题 × 6分 = 18分
第五部分:网络编程(10题,20分)
- 选择题:6题 × 2分 = 12分
- 简答题:2题 × 4分 = 8分
第六部分:智力与逻辑(5题,10分))
- 选择题/简答题:5题 × 2分 = 10分
本题库基于实际面试经验和技术需求整理,旨在帮助您:
- 系统复习C/C++核心概念
- 掌握常见面试题型和解题思路
- 提升编程思维和问题解决能力
- 为技术面试做好充分准备
题库内容经过精心编排,难度梯度合理,既适合初学者巩固基础,也适合有经验的开发者查漏补缺。
📝 考试说明
考试基本信息
- 考试时长:建议120分钟
- 总分:225分
- 题量:110题
- 及格线:135分(60%)
- 优秀线:180分(80%)
题型与分值分布
- 选择题:每题2分,共40题,80分
- 填空题:每空2分,共5题,10分
- 判断题:每题1分,共10题,10分
- 简答题:每题5分,共8题,40分
- 编程题:每题10分,共3题,30分
- 程序分析题:每题3分,共5题,15分
- 智力与逻辑题:每题2分,共5题,10分
答题要求
- 选择题、填空题、判断题请在答题卡上填写正确答案
- 简答题需简明扼要,突出重点
- 编程题需写出完整代码,并考虑边界条件和错误处理
- 程序分析题需分析代码逻辑、内存布局或输出结果
- 智力题需写出推理过程和最终答案
评分标准
- 选择题、填空题、判断题:答案正确即得满分
- 简答题:根据要点给分,关键概念缺失会扣分
- 编程题:功能完整、边界处理正确、代码规范可得分
- 程序分析题:分析准确、逻辑清晰可得分
- 智力题:推理过程正确、答案准确可得分
注意事项
- 考试期间不得查阅任何参考资料
- 编程题可使用任意IDE编写,但需提交最终代码
- 简答题和程序分析题需手写答案
- 考试结束后请检查个人信息和答题卡完整性
📋 试卷结构
| 部分 | 题型 | 题量 | 分值 |
|---|---|---|---|
| 第一部分 | C语言基础 | 35题 | 75分 |
| 第二部分 | C++核心特性 | 25题 | 50分 |
| 第三部分 | 数据结构与算法 | 20题 | 40分 |
| 第四部分 | Linux系统编程 | 15题 | 30分 |
| 第五部分 | 网络编程 | 10题 | 20分 |
| 第六部分 | 智力与逻辑 | 5题 | 10分 |
| 合计 | 110题 | 225分 | |
| ## 第一部分:C语言基础(25题,50分)0分) |
一、选择题(每题2分,共20分)
1. 在C语言中,以下哪个关键字用于声明常量?
A. static
B. const
C. final
D. define
答案:B
解析: const 是C语言中用于声明常量的关键字,被修饰的变量值不可修改。
2. 在32位Linux系统中,以下sizeof计算结果正确的是?
char str[] = "Hello";
char* p = str;
int n = 10;
A. sizeof(str)=5, sizeof§=4, sizeof(n)=4
B. sizeof(str)=6, sizeof§=4, sizeof(n)=4
C. sizeof(str)=6, sizeof§=8, sizeof(n)=4
D. sizeof(str)=5, sizeof§=8, sizeof(n)=4
答案:B
解析: 字符串"Hello"含5个字符,末尾自动添加’\0’,共6字节;32位系统指针占4字节,int占4字节。
3. 以下代码的执行结果是?
int a[5] = {1, 2, 3, 4, 5};
int* p = (int*)(&a + 1);
printf("%d, %d", *(a+1), *(p-1));
A. 2, 5
B. 2, 1
C. 1, 5
D. 不确定
答案:A
解析: &a+1 跳过整个数组(5个int),p-1 指向数组最后一个元素5,*(a+1) 是数组第2个元素2。
4. 以下关于指针数组和数组指针的说法,正确的是?
A. int *a[10] 表示一个指向含有10个整型元素的数组的指针
B. int (*a)[10] 表示一个有10个指针的数组,每个指针指向整型
C. int *a[10] 中 [] 优先级高于 *
D. int (*a)[10] 中 * 优先级高于 ()
答案:C
解析: int *a[10] 中 [] 优先级高于 *,表示有10个指针的数组;int (*a)[10] 中 () 优先级高于 [],表示指向含10个int数组的指针。
5. 有以下定义,32位系统下 sizeof(DATE) 和 sizeof(struct data) 分别是?
typedef union {
long i;
int k[5];
char c;
} DATE;
struct data {
int cat;
DATE cow;
double dog;
} too;
A. 20, 32
B. 20, 28
C. 24, 32
D. 20, 24
答案:A
解析: 联合体大小等于最大成员 int k[5] 的20字节;结构体 int(4)+DATE(20)+double(8)=32 字节。
6. 以下代码的问题是什么?
void GetMemory(char* p) {
p = (char*)malloc(100);
}
void Test() {
char* str = NULL;
GetMemory(str);
strcpy(str, "hello");
printf(str);
}
A. 内存泄漏
B. 对空指针解引用导致崩溃
C. 内存泄漏 + 对空指针解引用
D. 没有错误
答案:C
解析: 传参是值传递,p 是 str 的临时拷贝,malloc 不影响 str,str 仍为NULL导致崩溃;同时 malloc 的空间未释放导致内存泄漏。
7. 以下能正确输出"hello world"的修改方式是?
A. void GetMemory(char** p) { *p = (char*)malloc(100); }
B. char* GetMemory() { char p[] = "hello"; return p; }
C. void GetMemory(char* p) { p = (char*)malloc(100); strcpy(p, "hello"); }
D. 以上都可以
答案:A
解析: A使用二级指针正确修改了 str;B返回栈空间地址,函数返回后失效;C仍是值传递,str 仍为NULL。
8. 以下代码的输出结果是?
int main() {
int a[3][2] = {(0,1), (2,3), (4,5)};
int* p = a[0];
printf("%d", p[0]);
return 0;
}
A. 0
B. 1
C. 2
D. 编译错误
答案:B
解析: (0,1) 是逗号表达式,值为1,所以 a[0][0]=1,a[0][1]=3,a[1][0]=5。
9. 下列关于 sizeof 和 strlen 的说法,错误的是?
A. sizeof 是运算符,strlen 是函数
B. sizeof 在编译时计算,strlen 在运行时计算
C. sizeof 计算字符串长度时不包含 ‘\0’
D. strlen 遇到 ‘\0’ 停止计数
答案:C
解析: sizeof 计算的是占用内存大小,包含 ‘\0’;strlen 计算字符串长度,不包含 ‘\0’。
10. 以下关于 volatile 关键字的说法,正确的是?
A. volatile 告诉编译器该变量可能被意外修改
B. volatile 可以保证线程安全
C. volatile 修饰的变量不能进行算术运算
D. volatile 是C++11新增关键字
答案:A
解析: volatile 告诉编译器每次访问都从内存读取,禁止优化,用于多线程或硬件寄存器场景。
二、填空题(每空2分,共10分)
11. 写出以下定义:
- 一个有10个指针的数组,该指针指向整型数:
int *a[10]; - 一个指向有10个整型数数组的指针:
int (*a)[10]; - 一个指向函数的指针,该函数有1个整型参数并返回整型数:
int (*a)(int); - 一个有10个指针的数组,该指针指向函数(函数有1个整型参数并返回整型数):
int (*a[10])(int);
12. 以下代码的输出结果是:
int a[] = {1, 2, 3, 4, 5};
int* p = a;
printf("%d, %d", sizeof(a), sizeof(p));
32位系统输出:20, 4
64位系统输出:20, 8
三、简答题(每题5分,共10分)
13. 请说明 const 在C语言中的几种用法,并举例。
参考答案:
- 修饰普通变量:
const int a = 10;—— 值不可修改 - 修饰指针指向的内容:
const int* p = &a;——*p不可改,p可改 - 修饰指针本身:
int* const p = &a;——p不可改,*p可改 - 同时修饰:
const int* const p = &a;—— 都不可改 - 修饰函数参数:
void func(const char* s)—— 函数内不修改s指向的内容
14. 请说明 static 关键字在C语言中的作用。
参考答案:
- 修饰局部变量:生命周期延长至程序结束,首次执行到定义处初始化,保持上一次调用后的值
- 修饰全局变量/函数:作用域限制在当前文件(内部链接),其他文件不可见
- C++中还可修饰类成员(见第二部分)
四、编程题(10分)
15. 实现一个函数 void reverse(char* str),原地反转字符串。
#include <string.h>
void reverse(char* str) {
if (str == NULL) return;
int len = strlen(str);
int left = 0, right = len - 1;
while (left < right) {
char tmp = str[left];
str[left] = str[right];
str[right] = tmp;
left++;
right--;
}
}
测试用例:
#include <stdio.h>
#include <string.h>
#include <assert.h>
void test_reverse() {
// 测试用例1:正常字符串
char str1[] = "hello";
reverse(str1);
assert(strcmp(str1, "olleh") == 0);
printf("测试用例1通过: \"hello\" -> \"%s\"\n", str1);
// 测试用例2:空字符串
char str2[] = "";
reverse(str2);
assert(strcmp(str2, "") == 0);
printf("测试用例2通过: 空字符串\n");
// 测试用例3:单个字符
char str3[] = "a";
reverse(str3);
assert(strcmp(str3, "a") == 0);
printf("测试用例3通过: \"a\" -> \"%s\"\n", str3);
// 测试用例4:回文字符串
char str4[] = "level";
reverse(str4);
assert(strcmp(str4, "level") == 0);
printf("测试用例4通过: \"level\" -> \"%s\"\n", str4);
// 测试用例5:包含空格的字符串
char str5[] = "hello world";
reverse(str5);
assert(strcmp(str5, "dlrow olleh") == 0);
printf("测试用例5通过: \"hello world\" -> \"%s\"\n", str5);
// 测试用例6:NULL指针
reverse(NULL);
printf("测试用例6通过: NULL指针安全\n");
printf("所有测试用例通过!\n");
}
int main() {
test_reverse();
return 0;
}
评分标准:
- 正确实现反转功能(4分)
- 处理NULL指针(2分)
- 代码规范清晰(2分)
- 时间复杂度O(n),空间复杂度O(1)(2分)
77. 以下代码有什么问题?如何修正?
char* get_string() {
char str[] = "Hello World";
return str;
}
答案:返回局部数组地址
解析: str 是局部数组,函数返回后内存被释放,返回的指针成为悬垂指针。修正方法:使用 static 修饰或动态分配内存。
78. 分析以下代码的内存布局:
struct S {
char a;
int b;
char c;
double d;
};
在32位系统下,sizeof(struct S) 是多少?为什么?
答案:24字节
解析: 内存对齐:char a(1)+填充3→4,int b(4),char c(1)+填充7→8,double d(8),总24字节。
79. 以下代码的输出是什么?
#include <stdio.h>
#define SQUARE(x) x * x
int main() {
int a = 5;
printf("%d\n", SQUARE(a + 1));
return 0;
}
答案:11
解析: 宏展开为 a + 1 * a + 1 = 5 + 1 * 5 + 1 = 5 + 5 + 1 = 11。应定义为 #define SQUARE(x) ((x) * (x))。
80. 分析以下代码的递归调用过程:
#include <stdio.h>
void fun(int n) {
if (n > 0) {
printf("%d ", n);
fun(n - 1);
fun(n - 1);
}
}
int main() {
fun(3);
return 0;
}
答案:3 2 1 1 2 1 1
解析: 递归树:fun(3)打印3,调用fun(2)两次。每个fun(2)打印2,调用fun(1)两次,以此;
。
五、判断题(每题1分,共10分)
66. C语言中,sizeof 是一个函数,用于计算变量或类型的大小。
答案:错误
解析: sizeof 是C语言中的运算符,不是函数,它在编译时计算大小。
67. const 修饰的变量必须在定义时初始化。
答案:正确
解析: const 修饰的变量是只读的,必须在定义时初始化,之后不能修改。
68. 以下代码中,str 和 p 指向的是同一块内存:
char str[] = "Hello";
char* p = "Hello";
答案:错误
解析: str 是数组,在栈上分配内存;p 指向字符串常量,在只读数据段。
69. malloc 分配的内存会自动初始化为0。
答案:错误
解析: malloc 分配的内存内容是未初始化的随机值。calloc 会初始化为0。
70. 以下代码是合法的:
int arr[5] = {1, 2, 3, 4, 5};
int* p = &arr[5];
答案:正确
解析: 可以获取数组最后一个元素之后的位置的地址,但不能解引用。
71. static 局部变量的生命周期与程序相同。
答案:正确
解析: static 局部变量在程序开始运行时初始化,生命周期持续到程序结束。
72. 以下两个声明是等价的:
int* a, b;
int *a, *b;
答案:错误
解析: int* a, b; 中 a 是指针,b 是整型;int *a, *b; 中 a 和 b 都是指针。
73. #define 定义的宏在预处理阶段展开。
答案:正确
解析: 宏在预处理阶段进行文本替换,不进行类型检查。
74. 结构体的大小等于所有成员大小之和。
答案:错误
解析: 结构体大小受内存对齐影响,通常大于等于所有成员大小之和。
75. volatile 关键字可以保证变量的原子性。
答案:错误
解析: volatile 只告诉编译器不要优化,每次从内存读取,不保证原子性。需要原子操作应使用原子类型或锁。
``
第二部分:C++核心特性(25题,50分)
一、选择题(每题2分,共20分)
16. 下列关于指针与引用的区别,说法错误的是?
A. 指针可以为空,引用不能为空
B. 指针可以重新赋值,引用一旦绑定不可更改
C. 指针占用内存,引用不占用内存(编译器优化后)
D. 指针初始化以后不能被改变,引用可以改变所指的对象
答案:D
解析: D说反了——指针可以改变指向,引用一旦绑定不可更改。
17. 以下关于 new/delete 与 malloc/free 的区别,正确的是?
A. new 和 malloc 都会调用构造函数
B. delete 和 free 都会调用析构函数
C. new 失败返回NULL,malloc 失败抛异常
D. new 是运算符,malloc 是库函数
答案:D
解析: new/delete 是C++运算符,会调用构造/析构函数;malloc/free 是C库函数,不调用构造/析构。new 失败抛 std::bad_alloc,malloc 失败返回NULL。
18. 以下关于虚函数的描述,正确的是?
A. 派生类的虚函数与基类的虚函数可以有不同的参数个数和类型
B. 内联函数可以声明为虚函数
C. 虚函数地址存放在对象的虚表中,必须用对象指针或引用来调用
D. 静态成员函数可以是虚函数
答案:C
解析: 虚函数参数和返回值必须与基类一致(协变返回类型除外);内联函数是编译时展开,不能是虚函数(内联没有地址);静态成员函数无 this 指针,不能是虚函数。
19. 关于纯虚函数的说法,正确的是?
A. 声明纯虚函数的类可以实例化对象
B. 子类必须实现基类的所有纯虚函数才能实例化
C. 纯虚函数是一种特殊的虚函数,是空函数
D. 具有纯虚函数的类称为虚基类
答案:B
解析: 含有纯虚函数的类是抽象类,不能实例化对象;子类必须实现所有纯虚函数才能成为具体类。
20. 以下关于构造函数的执行顺序,正确的是?
class A { public: A(){cout << "A";} };
class B { public: B(){cout << "B";} };
class C : public A {
B b;
public:
C(){cout << "C";}
};
int main() { C obj; return 0; }
A. CBA
B. BAC
C. ACB
D. ABC
答案:C
解析: 构造顺序:基类构造函数 → 对象成员构造函数 → 派生类本身构造函数,输出 ACB。
21. 以下关于深浅拷贝的说法,正确的是?
A. 浅拷贝是复制指针指向的内容
B. 深拷贝只复制指针值
C. 浅拷贝可能导致双重释放
D. 深拷贝效率高于浅拷贝
答案:C
解析: 浅拷贝只复制指针值,多个指针指向同一块内存,析构时多次释放导致程序崩溃;深拷贝分配新内存并复制内容,更安全但效率较低。
22. 下列关于智能指针的说法,错误的是?
A. unique_ptr 独占资源,不能共享
B. shared_ptr 使用引用计数管理内存
C. weak_ptr 可以增加引用计数
D. weak_ptr 可以解决循环引用问题
答案:C
解析: weak_ptr 不增加引用计数,是对 shared_ptr 的弱引用,用于解决循环引用。
23. 以下关于 constexpr 的说法,正确的是?
A. constexpr 修饰的函数一定在编译期执行
B. constexpr 只能用于修饰变量
C. constexpr 可以用于常量表达式,提高编译效率
D. constexpr 是C++98引入的特性
答案:C
解析: constexpr 函数不一定总在编译期执行(取决于参数是否为常量表达式);可修饰变量和函数;C++11引入。
24. 以下关于移动语义的说法,正确的是?
A. 移动语义是C++98引入的特性
B. 移动语义通过左值引用实现
C. 移动语义可以避免不必要的拷贝,提高性能
D. 移动语义会增加代码量,不推荐使用
答案:C
解析: 移动语义是C++11引入,通过右值引用实现,在对象资源转移时避免不必要拷贝。
25. 以下关于STL容器的说法,正确的是?
A. vector 插入删除快,随机访问慢
B. list 随机访问快,插入删除慢
C. vector 随机访问快,插入删除慢(尾部插入除外)
D. list 和 vector 的插入删除时间复杂度相同
答案:C
解析: vector 连续存储,随机访问O(1),中间插入删除O(n);list 双向链表,随机访问O(n),插入删除O(1)。
二、填空题(每空2分,共10分)
26. 以下代码的输出结果是:
class A {
public:
virtual void foo() { cout << "A"; }
};
class B : public A {
public:
void foo() override { cout << "B"; }
};
int main() {
A* p = new B();
p->foo();
return 0;
}
输出:B
27. 以下代码中,sizeof(A) 在32位系统下的结果是:
struct A {
char a; // 1字节
int b; // 4字节
double c; // 8字节
};
输出:16
解析: 内存对齐:char(1)+填充3→4,int(4),double(8),总16字节。
三、简答题(每题5分,共10分)
28. 请说明 unique_ptr、shared_ptr、weak_ptr 的区别。
参考答案:
unique_ptr:独占式所有权,不能拷贝,只能移动。资源唯一持有者,销毁时自动释放shared_ptr:共享式所有权,引用计数管理。多个shared_ptr可共享同一资源,最后一个销毁时释放weak_ptr:弱引用,不增加引用计数。配合shared_ptr使用,解决循环引用问题,通过lock()获取shared_ptr
29. 什么是RAII?它在C++中有什么重要意义?
参考答案:
RAII(Resource Acquisition Is Initialization)是C++的核心编程范式:资源获取即初始化,资源释放即析构。
- 资源的获取在构造函数中完成,资源的释放在析构函数中完成
- 利用C++对象生命周期管理,保证资源在任何情况下(包括异常)都能正确释放
- 智能指针是RAII的典型应用:
unique_ptr、shared_ptr自动管理堆内存
四、编程题(10分)
30. 实现一个线程安全的单例模式(C++11及以后)。
#include <mutex>
class Singleton {
private:
Singleton() = default;
~Singleton() = default;
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static Singleton& getInstance() {
static Singleton instance; // C++11起线程安全
return instance;
}
};
或使用 std::call_once:
#include <mutex>
class Singleton {
private:
static Singleton* instance;
static std::once_flag flag;
Singleton() = default;
public:
static Singleton* getInstance() {
std::call_once(flag, []() {
instance = new Singleton();
});
return instance;
}
};
// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::flag;
测试用例:
#include <iostream>
#include <thread>
#include <vector>
#include <cassert>
void test_singleton() {
// 测试用例1:单线程测试
Singleton& s1 = Singleton::getInstance();
Singleton& s2 = Singleton::getInstance();
assert(&s1 == &s2);
std::cout << "测试用例1通过: 单线程单例唯一性" << std::endl;
// 测试用例2:多线程测试
std::vector<std::thread> threads;
std::vector<Singleton*> instances;
std::mutex mtx;
for (int i = 0; i < 10; ++i) {
threads.emplace_back([&mtx, &instances]() {
Singleton* instance = &Singleton::getInstance();
std::lock_guard<std::mutex> lock(mtx);
instances.push_back(instance);
});
}
for (auto& t : threads) {
t.join();
}
// 验证所有线程获取的是同一个实例
Singleton* first = instances[0];
for (size_t i = 1; i < instances.size(); ++i) {
assert(instances[i] == first);
}
std::cout << "测试用例2通过: 多线程单例唯一性" << std::endl;
// 测试用例3:不可拷贝
// Singleton s3 = s1; // 编译错误 - 正确
// Singleton s4(s1); // 编译错误 - 正确
std::cout << "测试用例3通过: 不可拷贝特性" << std::endl;
std::cout << "所有测试用例通过!" << std::endl;
}
int main() {
test_singleton();
return 0;
}
评分标准:
- 正确实现线程安全单例(4分)
- 防止拷贝构造和赋值(2分)
- 代码规范清晰(2分)
- 提供多线程测试用例(2分)
第三部分:数据结构与算法(20题,40分)
一、选择题(每题2分,共20分)
31. 以下哪种数据结构是线性结构?
A. 树
B. 图
C. 链表
D. 二叉树
答案:C
解析: 线性结构包括数组、链表、栈、队列;树和图是非线性结构。
32. 下列哪种排序算法的平均时间复杂度是 O(n²)?
A. 快速排序
B. 归并排序
C. 冒泡排序
D. 堆排序
答案:C
解析: 冒泡排序平均 O(n²);快速排序平均 O(n log n);归并排序 O(n log n);堆排序 O(n log n)。
33. 在链表中插入一个新节点的时间复杂度是?
A. O(1)
B. O(n)
C. O(log n)
D. 取决于插入位置
答案:D
解析: 链表插入本身O(1),但查找插入位置需要O(n)。
34. 以下哪个排序算法是不稳定的?
A. 冒泡排序
B. 插入排序
C. 归并排序
D. 快速排序
答案:D
解析: 快速排序、选择排序、希尔排序是不稳定排序;冒泡、插入、归并是稳定排序。
35. 在二叉搜索树中,以下哪个操作的时间复杂度是 O(log n)(平衡情况下)?
A. 插入
B. 删除
C. 查找
D. 以上都是
答案:D
解析: 平衡二叉搜索树的插入、删除、查找时间复杂度都是 O(log n)。
36. 以下哪种数据结构最适合实现栈操作?
A. 队列
B. 链表
C. 数组
D. 树
答案:C
解析: 数组实现栈操作简单高效,时间复杂度O(1)。
37. 以下关于链表的说法,正确的是?
A. 链表是一种非线性结构
B. 链表元素在内存中连续存储
C. 链表支持随机访问
D. 链表插入删除不需要移动元素
答案:D
解析: 链表是线性结构,元素不连续存储,不支持随机访问,插入删除只需修改指针。
38. 以下哪种数据结构适合用作优先队列的底层实现?
A. 哈希表
B. 平衡二叉搜索树
C. 双向链表
D. 循环队列
答案:B
解析: 堆(通常用数组实现)是优先队列的经典实现,平衡二叉搜索树也可实现优先队列功能。
39. 在C++中,以下哪个容器最适合实现LRU缓存?
A. vector
B. list + unordered_map
C. set
D. queue
答案:B
解析: LRU缓存需要快速查找(哈希表)和快速移动元素到头部(链表),list + unordered_map 是经典实现。
40. 以下关于时间复杂度的描述,正确的是?
A. O(1) < O(log n) < O(n) < O(n log n) < O(n²)
B. O(1) < O(n) < O(log n) < O(n log n) < O(n²)
C. O(log n) < O(1) < O(n) < O(n log n) < O(n²)
D. 以上都不对
答案:A
二、简答题(每题5分,共10分)
41. 请说明数组和链表的区别及各自的适用场景。
参考答案:
| 特性 | 数组 | 链表 |
|---|---|---|
| 内存 | 连续分配 | 非连续分配 |
| 随机访问 | O(1) | O(n) |
| 插入删除 | O(n)(需移动元素) | O(1)(已知位置) |
| 空间 | 固定/需扩容 | 动态 |
适用场景:
- 数组:频繁随机访问、数据量固定、内存连续性要求高的场景
- 链表:频繁插入删除、数据量动态变化、不需要随机访问的场景
42. 请说明快速排序的基本思想、时间复杂度及稳定性。
参考答案:
- 基本思想:分治法。选取基准元素,将数组分为小于基准和大于基准两部分,递归排序
- 时间复杂度:平均 O(n log n),最坏 O(n²)(已排序数组),最好 O(n log n)
- 空间复杂度:O(log n)(递归栈)
- 稳定性:不稳定
三、编程题(10分)
43. 实现单链表反转。
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(nullptr) {}
};
ListNode* reverseList(ListNode* head) {
ListNode* prev = nullptr;
ListNode* curr = head;
while (curr != nullptr) {
ListNode* next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
return prev;
}
测试用例:
#include <iostream>
#include <vector>
#include <cassert>
// 辅助函数:创建链表
ListNode* createList(const std::vector<int>& values) {
if (values.empty()) return nullptr;
ListNode* head = new ListNode(values[0]);
ListNode* current = head;
for (size_t i = 1; i < values.size(); ++i) {
current->next = new ListNode(values[i]);
current = current->next;
}
return head;
}
// 辅助函数:验证链表内容
bool verifyList(ListNode* head, const std::vector<int>& expected) {
ListNode* current = head;
for (int val : expected) {
if (current == nullptr || current->val != val) {
return false;
}
current = current->next;
}
return current == nullptr;
}
// 辅助函数:释放链表内存
void deleteList(ListNode* head) {
while (head != nullptr) {
ListNode* temp = head;
head = head->next;
delete temp;
}
}
void test_reverseList() {
// 测试用例1:正常链表
ListNode* list1 = createList({1, 2, 3, 4, 5});
ListNode* reversed1 = reverseList(list1);
assert(verifyList(reversed1, {5, 4, 3, 2, 1}));
std::cout << "测试用例1通过: 1->2->3->4->5 反转成功" << std::endl;
deleteList(reversed1);
// 测试用例2:空链表
ListNode* list2 = nullptr;
ListNode* reversed2 = reverseList(list2);
assert(reversed2 == nullptr);
std::cout << "测试用例2通过: 空链表处理" << std::endl;
// 测试用例3:单个节点
ListNode* list3 = createList({42});
ListNode* reversed3 = reverseList(list3);
assert(verifyList(reversed3, {42}));
std::cout << "测试用例3通过: 单节点链表" << std::endl;
deleteList(reversed3);
// 测试用例4:两个节点
ListNode* list4 = createList({1, 2});
ListNode* reversed4 = reverseList(list4);
assert(verifyList(reversed4, {2, 1}));
std::cout << "测试用例4通过: 1->2 反转成功" << std::endl;
deleteList(reversed4);
// 测试用例5:重复元素
ListNode* list5 = createList({1, 1, 2, 2, 3, 3});
ListNode* reversed5 = reverseList(list5);
assert(verifyList(reversed5, {3, 3, 2, 2, 1, 1}));
std::cout << "测试用例5通过: 含重复元素的链表" << std::endl;
deleteList(reversed5);
std::cout << "所有测试用例通过!" << std::endl;
}
int main() {
test_reverseList();
return 0;
}
评分标准:
- 正确实现链表反转(4分)
- 处理空链表和单节点链表(2分)
- 代码规范清晰(2分)
- 时间复杂度O(n),空间复杂度O(1)(2分)
第四部分:Linux系统编程(15题,30分)
一、选择题(每题2分,共12分)
44. 进程与线程的主要区别是?
A. 进程是调度的基本单位
B. 线程有独立的地址空间
C. 同一进程的线程共享地址空间
D. 进程比线程更轻量级
答案:C
解析: 进程是资源分配的基本单位,线程是调度的基本单位。同一进程的线程共享地址空间,进程间地址空间独立。
45. 以下哪种是进程间通信(IPC)的方式?
A. 管道
B. 共享内存
C. 消息队列
D. 以上都是
答案:D
解析: 常见的IPC方式包括:管道、共享内存、消息队列、信号量、Socket等。
46. 以下关于僵尸进程的描述,正确的是?
A. 僵尸进程会占用大量CPU
B. 僵尸进程已经结束,但父进程未回收其资源
C. 僵尸进程无法被杀死
D. 僵尸进程是正在运行的进程
答案:B
解析: 僵尸进程是已终止但父进程未调用 wait() 回收的进程,只占用进程表项,不占用CPU和内存。
47. 以下关于守护进程的描述,错误的是?
A. 守护进程在后台运行
B. 守护进程没有控制终端
C. 守护进程通常是系统启动时启动
D. 守护进程可以随意访问用户终端
答案:D
解析: 守护进程运行在后台,没有控制终端,不与用户交互。
48. 以下关于死锁的必要条件,不包括?
A. 互斥
B. 持有并等待
C. 抢占
D. 循环等待
答案:C
解析: 死锁四个必要条件:互斥、持有并等待、非抢占、循环等待。
49. 以下关于线程同步的说法,正确的是?
A. mutex 用于线程间同步
B. volatile 可以保证线程安全
C. 原子操作不能用于线程同步
D. 条件变量不能用于线程同步
答案:A
解析: mutex、条件变量、原子操作都可用于线程同步;volatile 不保证线程安全。
二、简答题(每题6分,共18分)
50. 请说明进程有哪几种状态,以及状态转换的触发事件。
参考答案:
进程状态:就绪 → 运行 → 阻塞 → 终止
- 就绪→运行:被调度程序选中
- 运行→就绪:时间片用完或被抢占
- 运行→阻塞:等待I/O、等待事件
- 阻塞→就绪:I/O完成、事件发生
- 运行→终止:正常结束或异常退出
51. 什么是孤儿进程?什么是僵尸进程?如何处理?
参考答案:
- 孤儿进程:父进程先于子进程结束,子进程被
init进程(PID=1)收养,由init负责回收 - 僵尸进程:子进程已结束,但父进程未调用
wait()回收其资源,进程描述符仍保留 - 处理方式:父进程调用
wait()或waitpid()回收;或使用信号处理SIGCHLD;父进程结束后僵尸进程由init回收
52. 请说明死锁的四个必要条件及避免死锁的策略。
参考答案:
四个必要条件:
- 互斥:资源一次只能被一个进程占用
- 持有并等待:进程持有资源并等待其他资源
- 非抢占:已分配的资源不能被强制抢占
- 循环等待:进程间形成资源等待环
避免策略:
- 破坏互斥:尽可能共享资源
- 破坏持有并等待:一次性申请所有资源
- 破坏非抢占:允许抢占
- 破坏循环等待:按固定顺序申请资源
第五部分:网络编程(10题,20分)
一、选择题(每题2分,共12分)
53. 以下哪个函数用于创建Socket?
A. connect()
B. socket()
C. bind()
D. listen()
答案:B
解析: socket() 创建套接字,bind() 绑定地址,listen() 监听,connect() 连接。
54. 以下关于TCP和UDP的说法,错误的是?
A. TCP是面向连接的协议
B. TCP提供可靠的数据传输服务
C. UDP是面向连接的协议
D. UDP不保证数据包顺序
答案:C
解析: UDP是无连接的,不保证可靠传输和数据包顺序。
55. TCP建立连接需要几次握手?
A. 1次
B. 2次
C. 3次
D. 4次
答案:C
解析: TCP三次握手建立连接:SYN → SYN-ACK → ACK。
56. TCP断开连接需要几次挥手?
A. 2次
B. 3次
C. 4次
D. 5次
答案:C
解析: TCP四次挥手断开连接:FIN → ACK → FIN → ACK。
57. 以下哪个函数用于将网络字节序转换为主机字节序?
A. htonl()
B. ntohl()
C. htons()
D. 以上都是
答案:D
解析: htonl() 主机转网络长整型,htons() 主机转网络短整型,ntohl() 网络转主机长整型。
58. 以下关于Socket编程的说法,正确的是?
A. 服务端使用 connect() 等待连接
B. 客户端使用 listen() 监听端口
C. accept() 返回新的套接字用于通信
D. bind() 用于发送数据
答案:C
解析: 服务端:socket() → bind() → listen() → accept();客户端:socket() → connect()。accept() 返回新套接字用于与客户端通信。
二、简答题(每题4分,共8分)
59. 请说明TCP和UDP的主要区别及适用场景。
参考答案:
| 特性 | TCP | UDP |
|---|---|---|
| 连接 | 面向连接 | 无连接 |
| 可靠性 | 可靠传输 | 不可靠传输 |
| 顺序 | 保证顺序 | 不保证顺序 |
| 速度 | 较慢 | 较快 |
| 头部大小 | 20字节 | 8字节 |
适用场景:
- TCP:文件传输、HTTP、邮件等需要可靠传输的场景
- UDP:视频流、语音通话、DNS等实时性要求高的场景
60. 请简述TCP三次握手的过程。
参考答案:
- 第一次握手:客户端发送 SYN 报文(SYN=1,seq=x),进入 SYN_SENT 状态
- 第二次握手:服务端收到 SYN 后,回复 SYN-ACK 报文(SYN=1,ACK=1,seq=y,ack=x+1),进入 SYN_RCVD 状态
- 第三次握手:客户端收到 SYN-ACK 后,发送 ACK 报文(ACK=1,seq=x+1,ack=y+1),进入 ESTABLISHED
第六部分:智力与逻辑(5题,10分)
一、选择题/简答题(每题2分,共10分)
81. 25匹马,5个赛道,最少需要几场比赛才能找出最快的3匹马?
答案:7场
解析: 先分5组各跑1场(5场),每组第一再跑1场(1场),共6场确定最快马。再让最快马所在组的第二、三名,第二快马所在组的第一、二名,第三快马所在组的第一名共5匹马跑第7场,确定第二、第三名。
82. 有8个外观完全相同的球,其中1个稍重,用天平最少称几次能找出重球?
答案:2次
解析: 第一次:3 vs 3(若平衡,重球在剩余2个中,再称1次;若不平衡,重球在重的一侧3个中,再称1次)
83. 一个房间里有3个开关和3盏灯,开关在门外,灯在门内。你只能进房间一次,如何确定哪个开关控制哪盏灯?
参考答案:
- 打开第1个开关,等几分钟
- 关闭第1个开关,打开第2个开关
- 立即进房间
- 亮的灯由第2个开关控制
- 热的灯(不亮但发热)由第1个开关控制
- 冷的灯(不亮不热)由第3个开关控制
84. 有100层楼和2个鸡蛋,如何用最少次数确定鸡蛋从哪层扔下会碎?
参考答案:
从第14层开始扔,逐层递减(14, 27, 39, 50, 60, 69, 77, 84, 90, 95, 99, 100)。最坏情况需要14次。这是最优解。
85. 烧一根不均匀的绳子,从头烧到尾需要1小时。现有若干根相同的绳子,如何用它们测出45分钟?
参考答案:
- 同时点燃绳子的两端和另一根绳子的一端
- 第一根绳子两端同时烧完时,正好30分钟
- 此时第二根绳子还剩下30分钟的量
- 立刻点燃第二根绳子的另一端,从此刻到烧完正好15分钟
- 30 + 15 = 45分钟
- 8`**
解析: sizeof(a) 计算数组总大小(5个int,共20字节);sizeof§ 计算指针大小(32位4字节,64位8字节)。 - 以下代码的输出结果是:
int a = 5, b = 3;
printf(“%d, %d”, a+++b, a++ +b);
输出:8, 9
解析: a+++b 解析为 (a++) + b(5+3=8,a变为6);a++ +b 执行时a=6(6+3=9,a变为7)。
14. 以下代码的输出结果是:
char str[] = “Hello\0World”;
printf(“%d, %d”, sizeof(str), strlen(str));
输出:12, 5
解析: sizeof 计算包括’\0’的总大小(12字节);strlen 遇到第一个’\0’停止(5)。
15. 以下代码的输出结果是:
int a = 3, b = 5;
int c = a+++b;
printf(“%d, %d”, a, c);
输出:4, 8
解析: a+++b 解析为 (a++) + b(3+5=8,a变为4)。
三、判断题(每题1分,共10分)
16. int *p = malloc(10 * sizeof(int)); 分配的内存不会被自动初始化为0。(✓)
解析: malloc 不初始化内存,calloc 会初始化为0。
17. int a[10]; 和 int *a = malloc(10 * sizeof(int)); 分配的内存都在堆上。(×)
解析: int a[10] 在栈上,malloc 在堆上。
18. strcpy 比 memcpy 更安全,因为它会自动检查目标缓冲区大小。(×)
解析: strcpy 不检查缓冲区大小,memcpy 也不检查,strncpy 可指定最大拷贝数。
19. typedef 可以用于简化复杂的类型声明,但不创建新类型。(✓)
解析: typedef 为已有类型创建别名,不创建新类型。
20. const int *p 和 int const *p 含义相同,表示指针指向的内容不可变。(✓)
解析: 两种写法等价,*p 不可修改,p 可修改。
21. int *const p 表示指针本身不可变,但指向的内容可以修改。(✓)
解析: p 不可变,*p 可修改。
22. realloc 可以用于扩大或缩小内存块,但可能改变内存地址。(✓)
解析: realloc 可能原地调整大小或分配新内存并拷贝内容。
23. free(NULL) 是安全的,不会导致程序崩溃。(✓)
解析: C标准规定 free(NULL) 不执行任何操作。
24. struct 和 union 的大小都等于各成员大小之和。(×)
解析: struct 大小可能因对齐大于成员之和;union 大小等于最大成员大小。
25. #define 定义的宏在预处理阶段展开,const 变量在编译阶段处理。(✓)
解析: 宏是文本替换,const 是类型化常量。
四、简答题(每题5分,共10分)
26. 简述 strcpy、strncpy 和 memcpy 的区别。
答案:
strcpy:拷贝字符串,遇到’\0’停止,不检查目标缓冲区大小,不安全。
strncpy:指定最大拷贝字符数,避免溢出,但可能不添加’\0’。
memcpy:按字节拷贝指定长度的内存,不关心内容,效率高。
应用场景:
strcpy:已知目标缓冲区足够大时
strncpy:需要防止缓冲区溢出时
memcpy:拷贝任意二进制数据或结构体
- 解释以下声明并说明用途:
int (*(*func)(int))[10];
答案:
声明解析(从内到外):
func 是一个指针
指向一个函数,该函数接受 int 参数
函数返回一个指针,指向含有10个 int 的数组
简化理解:
func 是函数指针,接受 int 参数,返回指向 int[10] 的指针。
用途示例:
int arr[10];
int (get_array(int x))[10] { return &arr; }
int ((*func)(int))[10] = get_array;
用于动态获取固定大小数组的场景。
五、程序分析题(每题3分,共15分)
28. 分析以下代码的输出:
int main() {
int a = 5, b = 7;
int c = a+++b;
printf(“%d, %d, %d”, a, b, c);
return 0;
}
答案: 6, 7, 12
解析:
a+++b 解析为 (a++) + b
先计算 a + b(5+7=12),然后 a 自增为6
b 保持不变
- 分析以下代码的问题:
char* get_string() {
char str[] = “Hello”;
return str;
}
int main() {
char* p = get_string();
printf(“%s”, p);
return 0;
}
答案: 返回局部数组地址导致未定义行为
解析:
str 是栈上的局部数组,函数返回后内存失效
p 成为悬垂指针,访问可能导致崩溃或乱码
修正方法:使用 static 或动态分配
- 分析以下宏定义的问题:
#define SQUARE(x) x * x
int main() {
int a = 5;
printf(“%d”, SQUARE(a+1));
return 0;
}
答案: 输出 11 而非预期的 36
解析:
宏展开为 a+1 * a+1(即 5+15+1=11)
正确写法:#define SQUARE(x) ((x)(x))
宏参数应始终加括号
- 分析以下代码的输出:
int main() {
char* s = “Hello”;
s[0] = ‘h’;
printf(“%s”, s);
return 0;
}
答案: 运行时错误(尝试修改字符串常量)
解析:
“Hello” 是字符串常量,存储在只读段
s[0] = ‘h’ 尝试修改只读内存,导致段错误
正确做法:使用数组 char s[] = “Hello”;
- 分析以下代码的输出:
int main() {
int a = 0;
printf(“%d, %d, %d”, a, a++, ++a);
return 0;
}
答案: 输出依赖编译器,可能是 2, 1, 2
解析:
函数参数求值顺序未定义(从右到左或从左到右)
不同编译器可能产生不同结果
应避免在同一个表达式中混合使用自增和输出
六、编程题(10分)
33. 实现一个函数,将字符串中的空格替换为 “%20”(假设字符串有足够空间)
参考答案:
void replace_spaces(char* str) {
if (str == NULL) return;
int space_count = 0;
int original_len = strlen(str);
// 统计空格数量
for (int i = 0; i < original_len; i++) {
if (str[i] == ' ') space_count++;
}
int new_len = original_len + space_count * 2;
str[new_len] = '\0';
// 从后向前替换
for (int i = original_len - 1, j = new_len - 1; i >= 0; i--) {
if (str[i] == ' ') {
str[j--] = '0';
str[j--] = '2';
str[j--] = '%';
} else {
str[j--] = str[i];
}
}
}
解题思路:
先遍历字符串统计空格数量,计算新长度
从后向前处理,避免频繁移动字符
遇到空格则逆序填入 ‘%20’
时间复杂度 O(n),空间复杂度 O(1)
测试用例:
“Hello World” → “Hello%20World”
" " → “%20%20%20”
“NoSpaces” → “NoSpaces”
“” → “”
NULL → 不处理
📝 第一部分总结
本部分涵盖C语言核心知识点,包括指针、内存管理、数组与字符串、预处理器等。重点难点:
指针与数组的关系
内存分配与管理
复杂类型声明解析
字符串处理函数区别
宏定义与类型定义
建议通过实际编程练习加深理解,特别是指针操作和内存管理相关题目。
#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z
GPG: A2D0092CEE2E5BA87035600924C3704A8CC26D5F
主权锚定: #ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼♀️❤️♾️-DEVICE-BIND-SOUL
三色: 🟢 通过
题量: 100题
总分: 200分
═══════════════════════════════════════════════════
🐉 **丙午·甲申·辛丑·坤卦·🟢**
6917



被折叠的 条评论
为什么被折叠?



