计算机程序设计 · 2025 年真题（回忆版碎片 + 同型重构详解）

类型：考生回忆版碎片 + 同型题重构（C 级资料）| 满分 200 分 · 150 分钟 科目：广东普通专升本《计算机基础与程序设计》 体例来源：抖音「哎上课」莹莹老师 2025 真题讲解碎片 + 2024 同型题重构 边界：考试院不公开发布原卷。标注 ✅ 的为考生回忆确证考点，标注 🔄 的为同型重构题（考点一致、题面非原题）。见 00-资料来源与使用说明按考点拆练：考点拆分索引

---

试卷结构（2025 · 与 2024 完全一致）

题型	题量	分值	核心考查内容
一、单项选择题	20	60（3 分/题）	C 语法、运算符、数据结构概念
二、判断题	10	20（2 分/题）	C 语言细节、数据结构性质
三、填空题	5	20（4 分/题）	程序补全、数据结构术语
四、简答题	4	40（10 分/题）	概念辨析、算法思想
五、计算题	3	30（10 分/题）	程序执行结果、遍历序列
六、应用题	3	30（10 分/题）	手写 C 程序
合计		200

2025 考情特点（考生反馈）：

• ✅ 数据结构题量较往年略有增加
• ✅ 第 1 题考 sizeof
• ✅ 第 3 题考三目运算符（条件运算符）
• ✅ 考了字符串函数（strcpy/strcat/strcmp 类）
• ✅ 第 35 题考进制转换（十进制转其他进制）

---

一、单项选择题（本大题共 20 小题，每小题 3 分，共 60 分）

1. ✅ 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int a = 10;
    printf("%d, %d\n", sizeof(a), sizeof(int));
    return 0;
}

A. 10, 4 B. 4, 4 C. 4, 10 D. 10, 10

答案：B · 考点 1.2 数据的存储与运算

解析：sizeof 是运算符不是函数，返回类型或变量所占字节数。int 在 32/64 位系统通常占 4 字节，sizeof(a) 等价于 sizeof(int)，均为 4。注意 sizeof 不计算表达式的值，只看类型。

---

2. 🔄 C 语言中，以下合法的字符常量是（ ）

A. "\n" B. 'A' C. 'ab' D. a

答案：B · 考点 1.1 C语言概述与基本概念

解析：字符常量用单引号括单个字符。A 是字符串常量，C 单引号内不能有多个字符（部分编译器允许但值为最后一个字符，不标准），D 是标识符不是常量。

---

3. ✅ 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int a = 5, b = 3;
    printf("%d\n", a > b ? a : b);
    return 0;
}

A. 5 B. 3 C. 1 D. 0

答案：A · 考点 1.2 数据的存储与运算 · 三目运算符

解析：三目运算符 条件 ? 表达式1 : 表达式2，条件为真取表达式1，为假取表达式2。a > b 即 5 > 3 为真，取 a 的值 5。

变体考法：若 a < b ? a++ : b++，注意三目运算符只执行其中一个分支。

---

4. 🔄 表达式 sizeof("hello") 的值是（ ）

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

答案：B · 考点 1.6 数组 · 字符串

解析：字符串常量 "hello" 在内存中占 6 字节（5 个字符 + 1 个结束符 \0）。sizeof 计算整个数组大小，包含 \0。注意与 strlen("hello") 区分，后者返回 5（不计 \0）。

---

5. 🔄 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int x = 10;
    printf("%d\n", x > 5 ? (x < 8 ? 1 : 2) : 3);
    return 0;
}

A. 1 B. 2 C. 3 D. 10

答案：B · 考点 1.4 选择结构程序设计 · 嵌套三目

解析：嵌套三目运算符。x > 5 为真（10 > 5），执行 (x < 8 ? 1 : 2)；x < 8 为假（10 < 8 不成立），取 2。

---

6. ✅ 以下程序的输出结果是（ ）

#include <stdio.h>
#include <string.h>
int main() {
    char s[20] = "hello";
    char t[20] = "world";
    strcpy(s, t);
    printf("%s\n", s);
    return 0;
}

A. hello B. world C. helloworld D. 编译错误

答案：B · 考点 1.6 数组 · 字符串函数

解析：strcpy(s, t) 将 t 的内容（含 \0）复制到 s，覆盖原内容。复制后 s 变为 "world"。注意目标数组 s 必须足够大。

---

7. 🔄 以下程序的输出结果是（ ）

#include <stdio.h>
#include <string.h>
int main() {
    char s[20] = "hello";
    char t[20] = "world";
    strcat(s, t);
    printf("%d\n", strlen(s));
    return 0;
}

A. 5 B. 10 C. 11 D. 20

答案：B · 考点 1.6 数组 · 字符串函数

解析：strcat(s, t) 将 t 拼接到 s 末尾（覆盖 s 的 \0），结果 s = "helloworld"。strlen 不计 \0，长度为 10。

---

8. 🔄 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int a[5] = {1, 2, 3, 4, 5};
    int *p = a;
    printf("%d\n", *(p + 2));
    return 0;
}

A. 1 B. 2 C. 3 D. 4

答案：C · 考点 1.8 指针

解析：p 指向数组首元素 a[0]。p + 2 指向 a[2]（指针加法按类型大小偏移），*(p+2) 即 a[2] = 3。

---

9. 🔄 以下关于指针的叙述，正确的是（ ）

A. 指针变量可以存储任何类型的数据 B. int *p; p = 10; 是合法的 C. 指针变量的值是一个内存地址 D. 两个指针可以相加

答案：C · 考点 1.8 指针

解析：A 错，指针只能存地址；B 错，不能直接把整数赋给指针（除非强制转换）；D 错，C 语言不支持指针+指针。C 正确，指针变量存的就是内存地址。

---

10. 🔄 十进制数 15 转换为二进制是（ ）

A. 1101 B. 1110 C. 1111 D. 10000

答案：C · 考点 进制转换

解析：15 ÷ 2 = 7 余 1，7 ÷ 2 = 3 余 1，3 ÷ 2 = 1 余 1，1 ÷ 2 = 0 余 1。从下往上读：1111。

记忆：2⁴-1 = 15 = 1111(B)，2³ = 8 = 1000(B)。

---

11. 🔄 十进制数 25 转换为十六进制是（ ）

A. 19 B. 1A C. 1F D. 25

答案：A · 考点 进制转换

解析：25 ÷ 16 = 1 余 9，所以 25 = 0x19。

---

12. 🔄 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int i;
    for (i = 0; i < 5; i++) {
        if (i == 3) break;
        printf("%d ", i);
    }
    return 0;
}

A. 0 1 2 B. 0 1 2 3 C. 0 1 2 3 4 D. 1 2 3

答案：A · 考点 1.5 循环结构程序设计

解析：break 跳出整个循环。i=0,1,2 时打印，i=3 时 break 退出。输出 0 1 2。

---

13. 🔄 以下程序的输出结果是（ ）

#include <stdio.h>
int main() {
    int i, sum = 0;
    for (i = 1; i <= 10; i++) {
        if (i % 2 == 0) continue;
        sum += i;
    }
    printf("%d\n", sum);
    return 0;
}

A. 55 B. 25 C. 30 D. 45

答案：B · 考点 1.5 循环结构程序设计

解析：continue 跳过本次循环剩余语句。偶数时 continue，只累加奇数：1+3+5+7+9 = 25。

---

14. 🔄 以下关于栈的叙述，正确的是（ ）

A. 栈是先进先出的线性表 B. 栈只能在栈底进行插入和删除 C. 栈是后进先出的线性表 D. 栈可以在任意位置插入删除

答案：C · 考点 2.3 栈和队列

解析：栈（Stack）是后进先出（LIFO）的线性表，只能在栈顶进行插入（push）和删除（pop）。A 是队列的特点。

---

15. 🔄 一个栈的入栈序列是 1,2,3,4,5，则不可能的出栈序列是（ ）

A. 5,4,3,2,1 B. 2,1,5,4,3 C. 4,3,5,1,2 D. 1,2,3,4,5

答案：C · 考点 2.3 栈和队列

解析：C 中 4,3,5 出栈后，栈中剩余 1,2（1 在栈底，2 在栈顶），出栈必须 2 先于 1，不可能 1 先出。

---

16. 🔄 深度为 5 的完全二叉树，最少有（ ）个节点

A. 15 B. 16 C. 31 D. 32

答案：B · 考点 2.5 树和二叉树

解析：深度为 k 的完全二叉树最少节点数 = 前 k-1 层满 + 第 k 层 1 个 = 2^(k-1) - 1 + 1 = 2^(k-1) = 2^4 = 16。

---

17. 🔄 对序列 {5, 2, 8, 1, 9} 进行升序冒泡排序，第一趟排序后的结果是（ ）

A. {2, 5, 1, 8, 9} B. {2, 1, 5, 8, 9} C. {1, 2, 5, 8, 9} D.

答案：A · 考点 2.8 排序

解析：冒泡排序第一趟从左到右比较相邻元素，大的往后沉：

• 5>2 交换 →
• 5<8 不换
• 8>1 交换 →
• 8<9 不换 结果：

---

18. 🔄 以下排序算法中，稳定的是（ ）

A. 快速排序 B. 堆排序 C. 归并排序 D. 选择排序

答案：C · 考点 2.8 排序

解析：稳定排序：冒泡、插入、归并、基数。不稳定：选择、快速、堆、希尔。

---

19. 🔄 折半查找要求查找表必须是（ ）

A. 顺序存储的无序表 B. 顺序存储的有序表 C. 链式存储的无序表 D. 链式存储的有序表

答案：B · 考点 2.7 查找

解析：折半查找（二分查找）要求顺序存储且关键字有序。链式存储无法随机访问中间元素。

---

20. 🔄 含 10 个节点的二叉树，最少有（ ）层（根为第 1 层）

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

答案：B · 考点 2.5 树和二叉树

解析：每层最多 2^(k-1) 个节点。3 层最多 1+2+4=7 个 < 10，4 层最多 15 个 ≥ 10，所以最少 4 层。

---

二、判断题（本大题共 10 小题，每小题 2 分，共 20 分）

1. 🔄 C 语言中，sizeof 是一个函数。（ ）

答案：错 · 考点 1.2 数据的存储与运算

解析：sizeof 是运算符，不是函数。它在编译时计算，不计算操作数的值。

---

2. 🔄 三目运算符 ?: 是 C 语言中唯一的三目运算符。（ ）

答案：对 · 考点 1.2 数据的存储与运算

解析：C 语言中只有 ?: 是三目运算符，其他都是单目或双目。

---

3. 🔄 strcpy 函数会自动在目标字符串末尾添加 \0。（ ）

答案：对 · 考点 1.6 数组

解析：strcpy 会将源字符串的 \0 一起复制到目标，所以目标字符串以 \0 结尾。

---

4. 🔄 指针变量可以直接用整数赋值。（ ）

答案：错 · 考点 1.8 指针

解析：不能直接 p = 10;，需要强制转换 p = (int *)10;，且通常无意义。指针应存有效地址。

---

5. 🔄 数组名可以作为左值被修改。（ ）

答案：错 · 考点 1.6 数组

解析：数组名是常量指针（地址常量），不能被修改，不能做 a++ 或 a = p。

---

6. 🔄 栈和队列都是限制存取位置的线性表。（ ）

答案：对 · 考点 2.3 栈和队列

解析：栈只能在栈顶操作，队列只能在队尾插入、队头删除，都是受限的线性表。

---

7. 🔄 完全二叉树一定是满二叉树。（ ）

答案：错 · 考点 2.5 树和二叉树

解析：满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树（最后一层可以不满）。

---

8. 🔄 快速排序在最坏情况下的时间复杂度是 O(n²)。（ ）

答案：对 · 考点 2.8 排序

解析：快速排序平均 O(nlogn)，最坏（已有序）O(n²)。

---

9. 🔄 图的深度优先搜索（DFS）类似于树的先序遍历。（ ）

答案：对 · 考点 2.6 图

解析：DFS 尽可能深地搜索，类似于先序遍历（根→左→右的深度优先思路）。BFS 类似于层序遍历。

---

10. 🔄 散列表的装填因子越大，发生冲突的可能性越小。（ ）

答案：错 · 考点 2.7 查找

解析：装填因子 α = 元素数 / 表长，α 越大说明表越满，冲突可能性越大。

---

三、填空题（本大题共 5 小题，每小题 4 分，共 20 分）

1. 🔄 以下程序的输出结果是 ______

#include <stdio.h>
int main() {
    int a = 5, b = 3;
    printf("%d\n", a % b + a / b);
    return 0;
}

答案：3 · 考点 1.2 数据的存储与运算

解析：a % b = 5 % 3 = 2，a / b = 5 / 3 = 1（整数除法），2 + 1 = 3。

---

2. 🔄 以下程序的输出结果是 ______

#include <stdio.h>
int main() {
    int x = 10;
    printf("%d\n", x++ + ++x);
    return 0;
}

答案：22（注意：不同编译器可能有差异，标准 C 中此表达式行为未定义/未指定）

解析：x++ 先取值 10 再加 1，++x 先加 1 再取值。若按从左到右：x++ 取 10（x=11），++x 取 12（x=12），10+12=22。

注意：C 标准中函数参数/同一表达式中多次修改同一变量是未定义行为，考试通常按"从左到右"理解。

---

3. 🔄 以下程序的输出结果是 ______

#include <stdio.h>
#include <string.h>
int main() {
    char s[] = "hello";
    printf("%d, %d\n", sizeof(s), strlen(s));
    return 0;
}

答案：6, 5 · 考点 1.6 数组

解析：sizeof(s) 计算整个数组大小 = 5 字符 + \0 = 6；strlen(s) 不计 \0 = 5。

---

4. 🔄 深度为 k 的满二叉树有 ______ 个节点

答案：2^k - 1 · 考点 2.5 树和二叉树

解析：满二叉树每层节点数为 1, 2, 4, ..., 2^(k-1)，总和 = 2^k - 1。

---

5. 🔄 对 n 个元素进行归并排序，时间复杂度为 ______

答案：O(n log n) · 考点 2.8 排序

解析：归并排序最好、最坏、平均都是 O(n log n)，空间复杂度 O(n)。

---

四、简答题（本大题共 4 小题，每小题 10 分，共 40 分）

1. 🔄 简述 C 语言中指针和数组的区别与联系。（10 分）

参考答案：

区别：

1. 定义方式不同：数组 int a[10]; 分配连续内存；指针 int *p; 只分配指针变量空间
2. 数组名是地址常量，不能修改（不能 a++）；指针是变量，可以修改（p++）
3. sizeof(数组) 返回整个数组字节数；sizeof(指针) 返回指针变量大小（4 或 8 字节）
4. 数组不能直接赋值（a = b 非法）；指针可以赋值

联系：

1. 数组名在表达式中退化为指向首元素的指针
2. 数组元素可以用指针访问：a[i] 等价于 *(a + i)
3. 指针可以指向数组，通过指针遍历数组
4. 数组作为函数参数时退化为指针

---

2. 🔄 简述栈和队列的区别，并各举一个应用场景。（10 分）

参考答案：

区别：

特性	栈	队列
操作原则	后进先出（LIFO）	先进先出（FIFO）
插入位置	栈顶	队尾
删除位置	栈顶	队头
操作数	一端操作	两端操作

栈的应用：函数调用栈（保存返回地址和局部变量）、表达式求值、括号匹配、递归实现

队列的应用：操作系统进程调度、打印任务排队、广度优先搜索（BFS）、缓冲区

---

3. 🔄 简述二叉树的三种遍历方式，并写出对下图的遍历结果。（10 分）

        A
       / \
      B   C
     / \   \
    D   E   F

参考答案：

先序遍历（根→左→右）：A → B → D → E → C → F

中序遍历（左→根→右）：D → B → E → A → C → F

后序遍历（左→右→根）：D → E → B → F → C → A

遍历方法：

• 先序：先访问根节点，再遍历左子树，最后遍历右子树
• 中序：先遍历左子树，再访问根节点，最后遍历右子树
• 后序：先遍历左子树，再遍历右子树，最后访问根节点

---

4. 🔄 简述快速排序的基本思想，并分析其时间复杂度。（10 分）

参考答案：

基本思想（分治法）：

1. 选取一个基准元素（pivot，通常选第一个或最后一个）
2. 分区（partition）：将小于基准的放左边，大于基准的放右边
3. 递归对左右两个子序列分别进行快速排序
4. 递归终止条件：子序列长度为 0 或 1

时间复杂度：

• 最好情况（每次均分）：O(n log n)
• 平均情况：O(n log n)
• 最坏情况（已有序，每次选最大/最小为基准）：O(n²)

空间复杂度：O(log n)（递归栈），最坏 O(n)

稳定性：不稳定

---

五、计算题（本大题共 3 小题，每小题 10 分，共 30 分）

1. 🔄 分析以下程序的运行结果。（10 分）

#include <stdio.h>

void func(int a, int *b) {
    a = a * 2;
    *b = *b + a;
}

int main() {
    int x = 3, y = 5;
    func(x, &y);
    printf("%d, %d\n", x, y);
    return 0;
}

答案：3, 11

解析：

1. x = 3, y = 5
2. 调用 func(3, &y)：a=3（传值），b 指向 y
3. a = a * 2 → a = 6（不影响 x）
4. *b = *b + a → y = 5 + 6 = 11
5. 返回 main：x 仍为 3（传值不改变实参），y 变为 11
6. 输出：3, 11

---

2. 🔄 已知一棵二叉树的先序遍历为 ABDECF，中序遍历为 DBEAFC，画出该二叉树并写出后序遍历序列。（10 分）

参考答案：

构造过程：

1. 先序第一个 A 是根
2. 中序中 A 左边 DBE 是左子树，右边 FC 是右子树
3. 左子树先序 BDE，中序 DBE → B 是左子树根，D 左，E 右
4. 右子树先序 CF，中序 FC → C 是右子树根，F 是左孩子

二叉树结构：

        A
       / \
      B   C
     / \ /
    D  E F

后序遍历（左→右→根）：D → E → B → F → C → A

---

3. ✅ 将十进制数 35 转换为二进制、八进制、十六进制。（10 分）

参考答案：

转二进制（除 2 取余）： 35 ÷ 2 = 17 余 1 17 ÷ 2 = 8 余 1 8 ÷ 2 = 4 余 0 4 ÷ 2 = 2 余 0 2 ÷ 2 = 1 余 0 1 ÷ 2 = 0 余 1 从下往上：100011

转八进制（除 8 取余，或三位分组）： 35 ÷ 8 = 4 余 3 → 43 验证：4×8 + 3 = 35 ✓

转十六进制（除 16 取余）： 35 ÷ 16 = 2 余 3 → 23 验证：2×16 + 3 = 35 ✓

快速验证：100011(B) = 32+2+1 = 35 ✓

---

六、应用题（本大题共 3 小题，每小题 10 分，共 30 分）

1. 🔄 编写程序：输入一个字符串，统计其中大写字母、小写字母、数字和其他字符的个数。（10 分）

参考答案：

#include <stdio.h>
#include <string.h>

int main() {
    char s[100];
    int upper = 0, lower = 0, digit = 0, other = 0;
    int i = 0;

    printf("请输入字符串：");
    scanf("%s", s);

    while (s[i] != '\0') {
        if (s[i] >= 'A' && s[i] <= 'Z')
            upper++;
        else if (s[i] >= 'a' && s[i] <= 'z')
            lower++;
        else if (s[i] >= '0' && s[i] <= '9')
            digit++;
        else
            other++;
        i++;
    }

    printf("大写字母：%d\n", upper);
    printf("小写字母：%d\n", lower);
    printf("数字：%d\n", digit);
    printf("其他字符：%d\n", other);

    return 0;
}

评分要点：头文件（1分）、变量定义（1分）、输入（1分）、循环遍历（2分）、四类判断（3分）、输出（1分）、结束符（1分）

---

2. 🔄 编写函数：用指针实现两个整数的交换，并在主函数中调用验证。（10 分）

参考答案：

#include <stdio.h>

void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 3, y = 5;
    printf("交换前：x=%d, y=%d\n", x, y);
    swap(&x, &y);
    printf("交换后：x=%d, y=%d\n", x, y);
    return 0;
}

评分要点：函数参数用指针（3分）、解引用操作（2分）、中间变量（1分）、调用时传地址（2分）、输出验证（2分）

---

3. 🔄 编写程序：对一个整型数组进行冒泡排序（升序），并输出排序前后的结果。（10 分）

参考答案：

#include <stdio.h>

void bubbleSort(int a[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[10] = {5, 2, 9, 1, 7, 3, 8, 4, 6, 0};
    int i;

    printf("排序前：");
    for (i = 0; i < 10; i++)
        printf("%d ", arr[i]);
    printf("\n");

    bubbleSort(arr, 10);

    printf("排序后：");
    for (i = 0; i < 10; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

评分要点：函数定义（1分）、外层循环（2分）、内层循环边界（2分）、比较交换（2分）、数组传参（1分）、输出（1分）、格式（1分）

---

七、2025 真题确证碎片汇总

题号	考点	来源	置信度
第1题	sizeof	抖音莹莹老师讲解	✅ 高
第3题	三目运算符（条件运算符）	抖音莹莹老师讲解	✅ 高
字符串题	strcpy/strcat/strcmp	抖音莹莹老师讲解	✅ 高
第35题	进制转换（十进制转其他）	抖音真题讲解（四）	✅ 高
整体	数据结构题量增加	考生反馈	✅ 中

📌 以上标注 ✅ 的考点确证出现在 2025 真题中，但题面为同型重构（非原题文字）。标注 🔄 的为基于考纲和 2024 真题的同型练习题。

如需完整原题，建议购买正版真题册或等待机构陆续放出回忆版。

---

📊 下一份：《计算机 2026 题型变化》 · 📊 上一份：《计算机 2024 全卷详解》

---

← 回真题总览 · 2027 备考指南 · 知识点笔记