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

下列关于 Python 中继承和多态的描述中，错误的是（）。

• A.当使用父类类型变量指向子类对象并调用方法时，会执行子类重写后的方法
• B.子类通过重写父类中已有的方法，可以实现多态的效果
• C.Python 中不需要手动声明虚方法，普通方法默认就支持多态调用
• D.构造方法__init__可以在运行时动态绑定，因此能像普通方法一样实现多态创建对象

下列代码中，执行 d1.work() 和 d2.work() 输出不同结果的主要原因是（）。 1 class Device: 2 def work(self): 3 print("Device is working") 4 class Printer(Device): 5 def work(self): 6 print("Printer is printing") 7 class Scanner(Device): 8 def work(self): 9 print("Scanner is scanning") 10 if __name__ == '__main__': 11 d1 = Printer() 12 d2 = Scanner() 13 d1.work() 14 d2.work()

• A.Printer和Scanner使用了相同的构造函数
• B.子类重写了父类的work方法，Python 会根据对象实际类型调用对应版本的方法
• C.d1和d2是不同的变量
• D.程序中使用了del释放对象

下面代码在 main() 中有一行会导致错误，请找出来（）。 1 class Student: 2 def __init__(self, n, s): 3 self.__name = n 4 self.__score = s 5 def get_name(self): 6 return self.__name 7 def set_score(self, s): 8 self.__score = s 9 if __name__ == '__main__': 10 stu = Student("Tom", 85) 11 print(stu.get_name()) # ① 12 stu.set_score(90) # ② 13 print(stu.__score) # ③ 14 print(stu.get_name()) # ④

• A.第①行
• B.第②行
• C.第③行
• D.第④行

某文本编辑器把用户输入的字符依次压入栈 S。用户依次输入 X, Y, Z, W 后，连续执行两次撤销操作。每次撤销都会弹出栈顶一个字符。此时栈从栈底到栈顶的内容是（）。

• A.X Y
• B.X Y Z
• C.Y Z
• D.X Z

假设循环队列数组长度为 N = 7，队空判断条件为 front == rear。入队和出队操作如下： 1 N = 7 2 q = [0] * N 3 front = 3 4 rear = 3 5 def enqueue(x): 6 global rear 7 q[rear] = x 8 rear = (rear + 1) % N 9 def dequeue(): 10 global front 11 front = (front + 1) % N 依次执行： 12 enqueue(10) 13 enqueue(20) 14 enqueue(30) 15 dequeue() 16 enqueue(40) 17 dequeue() 18 enqueue(50) 最终 (front, rear) 的值是（）。

• A.(5, 1)
• B.(4, 0)
• C.(5, 0)
• D.(3, 1)

以下函数 check() 用于判断一棵二叉树是否为（）。 1 from collections import deque 2 class TreeNode: 3 def __init__(self, val=0, left=None, right=None): 4 self.val = val 5 self.left = left 6 self.right = right 7 def check(root): 8 if not root: 9 return True 10 q = deque() 11 q.append(root) 12 has_null = False 13 while q: 14 cur = q.popleft() 15 if not cur: 16 has_null = True 17 else: 18 if has_null: 19 return False 20 q.append(cur.left) 21 q.append(cur.right) 22 return True

• A.满二叉树
• B.完全二叉树
• C.二叉搜索树
• D.平衡二叉树

以下代码实现了二叉树的哪种遍历方式？（） 1 class TreeNode: 2 def __init__(self, val=0, left=None, right=None): 3 self.val = val 4 self.left = left 5 self.right = right 6 def traverse(root): 7 if not root: 8 return 9 print(root.val, end=' ') 10 traverse(root.left) 11 traverse(root.right)

• A.前序遍历
• B.中序遍历
• C.后序遍历
• D.层序遍历

已知一棵二叉树的先序遍历序列为：A B D E H C F G，中序遍历序列为：D B H E A F C G，则该二叉树的后序遍历序列是（）。

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

有 6 个字符，它们出现的次数分别为：{3, 4, 7, 8, 12, 15}，现在用哈夫曼编码为这些字符编码，最小加权路径长度 WPL 的值为（）。

• A.113
• B.119
• C.126
• D.31

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

• A.31
• B.32
• C.63
• D.64

在格雷码中，相邻两个编码只能有一位不同。若当前编码为 110，则它的下一个编码不可能是（）。

• A.010
• B.111
• C.100
• D.001

给定一棵二叉树，采用广度优先搜索 BFS 返回其右视图，其中右视图中的每个节点都是该层最右侧的节点。横线处应填写（）。 1 from collections import deque 2 class TreeNode: 3 def __init__(self, val=0, left=None, right=None): 4 self.val = val 5 self.left = left 6 self.right = right 7 def rightSideView(root): 8 result = [] 9 if not root: 10 return result 11 q = deque([root]) 12 while q: 13 sz = len(q) 14 for i in range(sz): 15 node = q.popleft() 16 __________________________ 17 if node.left: 18 q.append(node.left) 19 if node.right: 20 q.append(node.right) 21 return result

• A.if i == 0: result.append(node.val)
• B.if i == sz - 1: result.append(node.val)
• C.result.append(q[0].val)
• D.if node.right: result.append(node.right.val)

下面代码实现二叉搜索树的插入操作。假设树中不存在重复值，横线处应填写（）。 1 class TreeNode: 2 def __init__(self, val=0, left=None, right=None): 3 self.val = val 4 self.left = left 5 self.right = right 6 def insertNode(root, x): 7 if not root: 8 return TreeNode(x) 9 if x < root.val: 10 __________________________ 11 else: 12 root.right = insertNode(root.right, x) 13 return root

• A.root.left = insertNode(root.left, x)
• B.root = insertNode(root.left, x)
• C.root.right = insertNode(root.left, x)
• D.insertNode(root.left, x)

给定一个整数数组 a，每个元素表示一个位置上的数值。要求从数组中选择若干个元素，使得任意两个被选择的元素在原数组中都不相邻，并且所选元素的总和最大。函数 choose(a) 返回能够得到的最大总和，则横线处应填写（）。 1 def choose(a): 2 if not a: 3 return 0 4 n = len(a) 5 if n == 1: 6 return a[0] 7 dp = [0] * n 8 dp[0] = a[0] 9 dp[1] = max(a[0], a[1]) 10 for i in range(2, n): 11 dp[i] = __________________________ 12 return dp[-1]

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

下面代码实现 0/1 背包的一维动态规划。第 i 个物品重量为 wt[i]，价值为 val[i]，背包容量为 W。横线处应填写（）。 1 def knapsack(W, wt, val): 2 n = len(wt) 3 dp = [0] * (W + 1) 4 for i in range(n): 5 for w in range(W, wt[i] - 1, -1): 6 __________________________ 7 return dp[W]

• A.dp[w] = max(dp[w], dp[w - wt[i]] + val[i])
• B.dp[w] = max(dp[w - 1], dp[w - wt[i]] + val[i])
• C.dp[w] = dp[w] + val[i]
• D.dp[w - wt[i]] = max(dp[w], val[i])

Python 中没有虚方法的概念，__init__也不能声明为虚方法，且构造方法不实现运行时多态。

在 Python 中，执行 del 删除一个子类对象时，会自动先调用子类的 __del__ 方法，再调用父类的 __del__ 方法。

在 Python 标准库中，list 模拟栈时，list 非空的场景下，pop() 函数不传参数被调用时，会返回栈顶元素并将其删除。

程序运行后会输出 2。 1 from collections import deque 2 q = deque() 3 q.append(1) 4 q.append(2) 5 q.append(3) 6 q.popleft() 7 print(q[0])

以下函数可以正确完成二叉搜索树的插入，并保持二叉搜索树性质。 1 class TreeNode: 2 def __init__(self, x): 3 self.val = x 4 self.left = None 5 self.right = None 6 def insertNode(root, x): 7 if not root: 8 return TreeNode(x) 9 if x < root.val: 10 root.right = insertNode(root.right, x) 11 else: 12 root.left = insertNode(root.left, x) 13 return root

哈夫曼编码一定唯一，只要字符频率相同，得到的编码也一定完全相同。

若用数组按层序存储完全二叉树，且根节点下标为 0，则下标为 i 的节点左孩子下标为 2 * i + 1，右孩子下标为 2 * i + 2。

以下代码可以正确地按层换行输出二叉树的节点值。 1 from collections import deque 2 class TreeNode: 3 def __init__(self, val=0, left=None, right=None): 4 self.val = val 5 self.left = left 6 self.right = right 7 def printByLevel(root): 8 if not root: 9 return 10 q = deque([root]) 11 while q: 12 for i in range(len(q)): 13 cur = q.popleft() 14 print(cur.val, end=' ') 15 if cur.left: 16 q.append(cur.left) 17 if cur.right: 18 q.append(cur.right) 19 print()

使用栈非递归实现二叉树前序遍历时，若希望先访问左子树，通常应先将右孩子入栈，再将左孩子入栈。

动态规划问题通常要求具有最优子结构，并且常常存在重叠子问题。

试题名称：条形蛋糕 时间限制：1.0 s　内存限制：512.0 MB 题目描述：寒假到了，小杨同学打算找一份兼职，顺便体验一下打工人的生活。 小杨同学给一家蛋糕店发送了一份自己的简历，希望可以在寒假来这里帮忙。店长最近正好遇到了一个难题：店里每天会做一条长条蛋糕，但是不同长度的蛋糕块卖出的价格不同，应该怎么分才能卖得最多呢？ 有趣的是店长曾经学习过计算机专业。他最近对动态规划算法很感兴趣，于是打算用这个问题考一考小杨同学，问题如下： 给定一条长度为 n 的长条蛋糕和一个价格表，该价格表表示长度为 i（i = 1, 2, …, n）的蛋糕块的价格为 p_i。求蛋糕的分割方案，使得总销售价格最大，注意蛋糕块的长度必须为整数。 输入格式：第一行一个正整数 n（1 ≤ n ≤ 10^3），表示长条蛋糕的总长度。 第二行 n 个正整数 p_1, p_2, …, p_n（1 ≤ p_i ≤ 10^5），表示不同长度蛋糕块的价格。 输出格式：一行一个正整数，表示最大总销售价格。 输入样例1：4 1 5 8 9 输出样例1：10 输入样例2：10 1 5 8 9 10 17 17 20 24 30 输出样例2：30 样例解释1：第一个样例中，长度为 1 的蛋糕价值为 1，长度为 2 的蛋糕价值为 5，长度为 3 的蛋糕价值为 8，长度为 4 的蛋糕价值为 9；总长度为 4 的长条蛋糕，有 {4}, {1,3}, {2,2}, {1,1,2}, {1,1,1,1} 五种本质不同的分法。其对应的总销售价格分别为 9, 9, 10, 7, 4，故最大总销售价格为 10。第二个样例中，长度为 10 的长条蛋糕，销售价格最大的分法为 {10}，最大总销售价格为 30。

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

试题名称：满二叉树 时间限制：1.0 s　内存限制：512.0 MB 题目描述：给定一棵包含 n 个结点的有根二叉树，结点依次以 1, 2, …, n 编号，根结点编号为 1。 对于结点 i，其左儿子的编号记为 l_i，右儿子编号记为 r_i。特别地，如果左儿子不存在则 l_i = 0，如果右儿子不存在则 r_i = 0。 树中每个结点都对应一棵以其为根的子树。请你求出给定有根树的所有 n 棵子树中，有多少棵子树是满二叉树。 满二叉树是指所有叶子深度均相同，且除叶子外均有两个儿子的二叉树，例如以下三棵二叉树均是满二叉树： 例如， 在上面这棵有 3 个节点的二叉树中，有 3 个子树是满二叉树（包括整个树本身，及所有的单个叶子节点）； 又例如， 在上面这棵有 5 个节点的二叉树中，有 4 个子树是满二叉树（包括节点 3 的子树，以及所有单个叶子节点）。 输入格式：第一行，一个正整数 n，表示有根二叉树结点数量。 接下来 n 行，每行两个非负整数 l_i, r_i，表示结点 i 的左儿子编号和右儿子编号，整数之间以空格分隔。 输出格式：输出一行，一个整数，表示所有子树中满二叉树的数量。 输入样例1：4 2 3 4 0 0 0 0 0 输出样例1：2 输入样例2：3 2 3 0 0 0 0 输出样例2：3 数据范围：对于 40% 的测试点，保证 1 ≤ n ≤ 500。 对于所有测试点，保证 1 ≤ n ≤ 10^5。

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