GESP Python 编程六级 · 2026 年 3 月卷

以下关于 Python 类继承的代码，执行后输出结果是？（） 1 class Animal: 2 def __init__(self, name): 3 self.name = name 4 def speak(self): 5 return "动物叫声" 6 class Dog(Animal): 7 def speak(self): 8 return f"{self.name}：汪汪汪" 9 class Cat(Animal): 10 def __init__(self, name, color): 11 super().__init__(name) # 调用父类构造方法 12 self.color = color 13 def speak(self): 14 return f"{self.name}（{self.color}）：喵喵喵" 15 dog = Dog("旺财") 16 cat = Cat("咪宝", "橘色") 17 print(dog.speak(), cat.speak())

• A.动物叫声 动物叫声
• B.旺财：汪汪汪 咪宝：喵喵喵
• C.旺财：汪汪汪 咪宝（橘色）：喵喵喵
• D.动物叫声 咪宝（橘色）：喵喵喵

下列代码中，s1.draw()和s2.draw()能正确运行并输出不同结果的主要原因是（）。 1 class Shape: 2 def draw(self): 3 print("绘制图形") 4 class Circle(Shape): 5 def draw(self): 6 print("绘制圆形") 7 class Rectangle(Shape): 8 def draw(self): 9 print("绘制矩形") 10 if __name__ == "__main__": 11 s1 = Circle() 12 s2 = Rectangle() 13 s1.draw() 14 s2.draw()

• A.draw()是普通成员函数
• B.Shape中的draw()被声明为虚函数
• C.Circle和Rectangle中使用了公有继承
• D.对象变量名不同

下面的代码在主程序if __name__ == "__main__":中有没有一行会导致运行错误，如果有请找出错误行（） 1 class Pet: 2 def __init__(self, n, a): 3 self._name = n 4 self._age = a 5 def get_name(self): 6 return self._name 7 def birthday(self): 8 self._age += 1 9 if __name__ == "__main__": 10 cat = Pet("奶茶", 2) 11 print(cat.get_name()) # ① 12 cat.birthday() # ② 13 cat._name = "大橘" # ③ 14 print(cat.get_name()) # ④

• A.第①行
• B.第②行
• C.第③行
• D.无错误行

游乐园的过山车每次限坐 4 人，用循环队列管理排队（容量 MAX=5，空一格判满）。下面代码执行后，循环队列是否已满？rear 的值是多少？ 1 MAX = 5 2 queue = [None] * MAX 3 front = 0 4 rear = 0 5 def enqueue(x): 6 global rear, queue 7 queue[rear] = x 8 rear = (rear + 1) % MAX 9 def dequeue(): 10 global front 11 front = (front + 1) % MAX 12 if __name__ == "__main__": 13 enqueue(1) 14 enqueue(2) 15 enqueue(3) 16 enqueue(4) 17 dequeue() 18 dequeue() 19 enqueue(5) 20 enqueue(6) 21 print("队列数组：", queue) 22 print("front下标位置：", front) 23 print("rear下标位置：", rear)

• A.已满，rear = 1
• B.未满，rear = 1
• C.已满，rear = 2
• D.未满，rear = 4

在以下计算机系统应用场景中，最适合使用循环队列的是（）。

• A.函数调用过程中，保存局部变量和返回地址
• B.表达式求值中的运算符优先级处理
• C.操作系统中的进程优先级调度（高优先级先执行）
• D.生产者和消费者问题中的共享缓冲区

在二叉搜索树（BST）中，若中序遍历的序列为 {1, 2, 3, 4, 5}，且先序遍历的第一个序列元素为 3，则下列说法正确的是（）。

• A.该树一定是一棵完全二叉树。
• B.元素4和5不可能是兄弟节点。
• C.元素1所在节点的深度可能大于3（根节点深度为1）。
• D.元素2一定是元素1的父节点。

某二叉树共有10个结点，记为A~J，已知它的先序遍历序列为：A B D H I E C F J G，中序遍历序列为：H D I B E A F J C G，则该二叉树的后序遍历序列是（）。

• A.H I D E B J F G C A
• B.H I D B E J F G C A
• C.I H D E B J F G C A
• D.H I D E B F J G C A

下列关于树的遍历的说法中，正确的一项是（）。

• A.对任意一棵树进行深度优先遍历，所得序列一定唯一。
• B.已知一棵二叉树的先序遍历和后序遍历序列，可以唯一确定这棵二叉树。
• C.若一棵二叉树的先序遍历序列与中序遍历序列相同，则该二叉树一定为只有右子树的链式结构。
• D.已知一棵二叉树的先序遍历序列，即可唯一地确定该二叉树的结构。

有 6 个字符，它们出现的次数分别为：{2, 3, 3, 4, 6, 8}，现在用哈夫曼编码为这些字符编码，最小加权路径长度 WPL（每个字符的出现次数×它的编码长度，再把每个字符结果加起来）的值为（）。

• A.58
• B.60
• C.62
• D.64

对 n 个不同符号的符号进行哈夫曼编码。若生成的哈夫曼树共有 115 个结点，则 n 的值是（）。

• A.60
• B.58
• C.57
• D.56

关于格雷编码（Gray Code），下列说法正确的是（）。

• A.格雷编码中，编码位数越多，相邻编码之间变化的位数也越多
• B.格雷编码中，相邻两个编码的二进制位恰好有一位不同
• C.格雷编码就是把普通二进制编码按位取反后得到的结果
• D.格雷编码不能用于数字电路和状态转换的设计中

给定一棵二叉树，采用广度优先搜索 (BFS) 算法，返回右视图所有节点的值。其中右视图定义为：二叉树的右视图是从树的右侧看过去时可见的节点集合，即右视图中的每个节点都是某一层中最右侧的节点。 1 class TreeNode: 2 def __init__(self, x): 3 self.val = x 4 self.left = None 5 self.right = None 6 def rightSideView(root): 7 rightmost_value_at_depth = {} 8 max_depth = -1 9 node_queue = [] 10 depth_queue = [] 11 node_queue.append(root) 12 depth_queue.append(0) 13 while node_queue: 14 node = node_queue.pop(0) 15 depth = depth_queue.pop(0) 16 if node is not None: 17 max_depth = max(max_depth, depth) 18 rightmost_value_at_depth[depth] = node.val 19 node_queue.append(node.left) 20 node_queue.append(node.right) 21 # (1) 22 depth_queue.append(__________) 23 depth_queue.append(__________) 24 right_view = [] 25 # (2) 补全 26 for depth in range(____________): 27 right_view.append(rightmost_value_at_depth[depth]) 28 return right_view 29 if __name__ == "__main__": 30 root = TreeNode(1) 31 root.left = TreeNode(2) 32 root.right = TreeNode(3) 33 root.left.right = TreeNode(5) 34 root.right.right = TreeNode(4) 35 print(rightSideView(root))

• A.（1）depth, depth ;（2）0, max_depth
• B.（1）depth + 1, depth + 1 ;（2）0, max_depth + 1
• C.（1）depth + 1, depth + 1 ;（2）1, max_depth + 1
• D.（1）depth, depth ;（2）1, max_depth

下列关于树的深度优先搜索（DFS）的说法中，正确的是（）。

• A.对树进行 DFS 时，一定是按层从上到下依次访问结点
• B.对任意一棵树进行 DFS，得到的遍历序列唯一
• C.对一棵树进行 DFS 时，常借助递归或栈实现
• D.DFS 只能用于二叉树，不能用于普通树

小朋友们去邻里拜年，每个家里有不同数量的糖果。规则是：不能连续进入两个相邻的房子（即不能同时取相邻两家的糖果）。目标是拿到最多糖果。以下是代码实现，请补全横线。 1 def visit(nums): 2 if not nums: 3 return 0 4 size = len(nums) 5 if size == 1: 6 return nums[0] 7 dp = [0] * size 8 dp[0] = nums[0] 9 dp[1] = max(nums[0], nums[1]) 10 for i in range(2, size): 11 __________________________ 12 return dp[size - 1] 13 if __name__ == "__main__": 14 nums1 = [1,2,3,1] 15 print(visit(nums1)) 16 nums2 = [2,7,9,3,1] 17 print(visit(nums2)) 18 nums3 = [5] 19 print(visit(nums3)) 20 nums4 = [] 21 print(visit(nums4))

• A.dp[i] = dp[i - 1] + nums[i]
• B.dp[i] = max(dp[i - 1], dp[i - 2] * nums[i])
• C.dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
• D.dp[i] = dp[i - 2] + nums[i]

元宵节晚上，小朋友沿着一条发光石板路前进，每次可以向前走 1 块或 2 块石板。若dp[i] = dp[i - 1] + dp[i - 2]，下面关于dp[i]的含义最合适的是（）。

• A.走到第 i 块石板的不同走法数量
• B.走到第 i 块石板时，已经走过的石板总数
• C.从第 i 块石板走回起点的最少步数
• D.从第 i 块石板走回起点的最大步数

下面定义了一个表示二维坐标点的类 Point，并提供了一个带参数的构造函数，但第②行 Point b; 会调用编译器自动生成的默认构造函数，将 b.x 和 b.y 被初始化为 0.0，程序可以正常编译运行。 1 class Point: 2 def __init__(self, px, py): 3 self.x = px 4 self.y = py 5 def print(self): 6 print(f"({self.x}, {self.y})") 7 if __name__ == "__main__": 8 a = Point(3.0, 4.0) # ① 9 # ② 10 b = Point() 11 a.print()

Python 中的继承支持单继承和多继承，但子类无法直接访问父类的私有成员。

对如下结构的树，执行travel函数，输出结果是1 2 3 4 5。 1 class Node: 2 def __init__(self, v): 3 self.val = v 4 self.left = None 5 self.right = None 6 def travel(root): 7 if not root: 8 return 9 stack = [] 10 stack.append(root) 11 while stack: = 12 cur = stack.pop() 13 print(cur.val, end=" ") 14 if cur.right: 15 stack.append(cur.right) 16 if cur.left: 17 stack.append(cur.left) 18 if __name__ == "__main__": 19 root = Node(1) 20 root.left = Node(2) 21 root.right = Node(3) 22 root.left.left = Node(4) 23 root.left.right = Node(5) 24 travel(root)

若所有字符出现频率相同，则哈夫曼编码一定会得到完全二叉树。

哈夫曼编码是一种变长的前缀编码，在解码时不需要额外的分隔符就能唯一还原，这是因为在哈夫曼树中，任何一个字符的叶子结点都不会成为另一个字符结点的祖先。

在 Python 中使用列表存储按层序遍历的完全二叉树时，若根节点存储在 tree[0]，则对于任意非空节点 tree[i]，其右孩子（如果存在）必然位于 tree[2 * i + 2]。

在 Python 中使用列表模拟栈来非递归地实现二叉树的前序遍历，为了保证遍历顺序正确，在处理完当前结点后，应该先将该结点的左孩子压入栈中，然后再将右孩子压入栈中。（）

设二叉树共有 n 个结点，函数preorderTraversal的时间复杂度为 O(n)，空间复杂度为 O(n)。 1 class TreeNode: 2 def __init__(self, x): 3 self.val = x 4 self.left = None 5 self.right = None 6 def preorder(root, res): 7 if root is None: 8 return 9 res.append(root.val) 10 preorder(root.left, res) 11 preorder(root.right, res) 12 def preorderTraversal(root): 13 res = [] 14 preorder(root, res) 15 return res 16 if __name__ == "__main__": 17 root = TreeNode(1) 18 root.right = TreeNode(2) 19 root.right.left = TreeNode(3) 20 result = preorderTraversal(root) 21 print("前序遍历结果：", result)

以下代码实现了0-1背包问题的一维动态规划解法，内层循环采用经典的逆序遍历方式。若将内层循环改为正序遍历（即for j in range(w[i], W + 1):），仍能得到正确答案。 1 def knapsack_01(): 2 W = 5 3 w = [2, 3, 4] 4 v = [10, 1, 1] 5 n = 3 6 dp = [0] * (W + 1) 7 for i in range(n): 8 for j in range(W, w[i] - 1, -1): 9 dp[j] = max(dp[j], dp[j - w[i]] + v[i]) 10 print(dp[W]) 11 knapsack_01()

在动态规划问题中，状态空间相同且没有重复计算的情况下，“状态转移方程+递推”与“递归+记忆化搜索”的时间复杂度通常相同。

试题名称：选数 时间限制：1.0 s　内存限制：512.0 MB 题目描述：给定两个包含 n 个整数的数组 a = [a_1, …, a_n] 与 b = [b_1, …, b_n]。你需要指定若干下标 p_1 < ⋯ < p_k（1 ≤ k ≤ n）使得以下条件成立： 1 ≤ p_i ≤ n（1 ≤ i ≤ k）； p_{i+1} ≥ p_i + b_{p_i}（1 ≤ i < k）。 你需要在满足以上条件的前提下最大化 ∑_{i=1}^k a_{p_i}，也即最大化数组 a 对应下标的整数之和。 输入格式：第一行，一个正整数 n，表示数组长度。 第二行，n 个非负整数 a_1, a_2, …, a_n，表示数组 a。 第三行，n 个非负整数 b_1, b_2, …, b_n，表示数组 b。 输出格式：一行，一个整数，表示在满足下标条件的前提下，数组 a 对应下标的整数之和的最大值。 输入样例1：4 1 2 3 4 3 3 1 1 输出样例1：7 输入样例2：6 1 1 4 5 1 4 1 2 3 2 1 0 输出样例2：11 数据范围：对于 40% 的测试点，保证 2 ≤ n ≤ 10^3。 对于所有测试点，保证 2 ≤ n ≤ 10^5，0 ≤ a_i ≤ 10^9，0 ≤ b_i ≤ n。

作答说明：按题目要求完成程序或作品；需要在线运行与自动判分时，可在站内选择「在线考试」。

试题名称：完全二叉树 时间限制：1.0 s　内存限制：512.0 MB 题目描述：给定一棵包含 n 个结点的有根二叉树，结点依次以 1, 2, …, n 编号，根结点编号为 1。 对于结点 i，其左儿子的编号记为 l_i，右儿子编号记为 r_i。特别地，如果左儿子不存在则 l_i = 0，如果右儿子不存在则 r_i = 0。 树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中，有多少棵子树是完全二叉树。 输入格式：第一行，一个正整数 n，表示有根二叉树结点数量。 接下来 n 行，每行两个正整数 l_i, r_i，表示结点 i 的左儿子编号和右儿子编号。 输出格式：输出一行，一个整数，表示所有子树中完全二叉树的数量。 输入样例1：4 2 3 4 0 0 0 0 0 输出样例1：4 输入样例2：4 2 3 0 0 4 0 0 0 输出样例2：3 数据范围：对于 40% 的测试点，保证 1 ≤ n ≤ 500。 对于所有测试点，保证 1 ≤ n ≤ 10^5。

作答说明：按题目要求完成程序或作品；需要在线运行与自动判分时，可在站内选择「在线考试」。