GESP Python 6级 2025.12

在Python的⾯向对象编程中，下列关于“动态绑定（等效于虚函数）”的描述中，错误的是（ ）。

执⾏如下代码，将输出 钢琴：叮咚叮咚 和 吉他：咚咚当当 ⽽不是两⾏ 乐器在演奏声音，这体现了⾯向对象编程的（ ）特性。

class Instrument:
 """基类：乐器"""
 def play(self):
 print("乐器在演奏声音")

 def __del__(self):
 pass

class Piano(Instrument):
 """子类：钢琴"""
 def play(self):
 print("钢琴：叮咚叮咚")

class Guitar(Instrument):
 def play(self):
 print("吉他：咚咚当当")

if __name__ == "__main__":
 instruments = [Piano(), Guitar()]

 for inst in instruments:
 inst.play()

执⾏下⾯代码，将输出（ ）。

class Instrument:
 def play(self):
 print("乐器在演奏声音")

 def __del__(self):
 pass

class Piano(Instrument):
 def play(self):
 print("钢琴：叮咚叮咚")

class Guitar(Instrument):
 def play(self):
 print("吉他：咚咚当当")

if __name__ == "__main__":
 instruments = [Piano(), Guitar()]
 for inst in instruments:
 Instrument.play(inst) 

某⽂本编辑器把⽤户输⼊的字符依次压⼊栈 S。⽤户依次输⼊ A , B, C, D 后，⽤户按了两次撤销（每次撤销，弹出栈顶⼀个字符）。此时栈从栈底到栈顶的内容是：（ ）。

假设循环队列数组长度为 N，其中队空判断条件为：front == rear ，队满判断条件为 (rear + 1) % N == front ，出队对应的操作为：front = (front + 1) % N，⼊队对应的操作为：rear = (rear + 1) % N。循环队列长度 N = 6，初始 front = 1 , rear = 1 ，执⾏操作序列为：⼊队, ⼊队, ⼊队, 出队, ⼊队, ⼊队，则最终 (front, rear) 的值是（ ）。

以下函数 check() ⽤于判断⼀棵⼆叉树是否为（ ）。

class TreeNode:
 def __init__(self, val=0, left=None, right=None):
 self.val = val
 self.left = left
 self.right = right

from collections import deque 

def check(root):
 if not root: 
 return True
 
 q = deque()
 q.append(root)
 has_null = False 
 
 while q: 
 cur = q.popleft() 
 
 if not cur: 
 has_null = True
 else: 
 if has_null: 
 return False
 q.append(cur.left)
 q.append(cur.right)
 
 return True

以下代码实现了⼆叉树的（ ）。

class TreeNode:
 def __init__(self, val=0, left=None, right=None):
 self.val = val
 self.left = left
 self.right = right

def traverse(root):
 if not root: 
 return
 traverse(root.left)
 traverse(root.right)
 print(root.val, end=" ")

if __name__ == "__main__":
 root = TreeNode(1)
 root.right = TreeNode(2)
 root.right.left = TreeNode(3)

 print("后序遍历结果：", end="")
 traverse(root) 

下⾯代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。

class Symbol:
 def __init__(self, ch='', freq=0, code=''):
 self.ch = ch 
 self.freq = freq 
 self.code = code 

class Node:
 def __init__(self, w=0, l=-1, r=-1, sym=-1):
 self.w = w 
 self.l = l 
 self.r = r 
 self.sym = sym 

def pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB):

 if pA[0] = len(internal_idx) or nodes[leaf_idx[pA[0]]].w <= nodes[internal_idx[pB[0]]].w):
 res = leaf_idx[pA[0]]
 pA[0] += 1
 return res
 else:
 res = internal_idx[pB[0]]
 pB[0] += 1
 return res

def dfs_build_codes(u, nodes, sym_list, path):
 if u == -1:
 return
 if nodes[u].sym != -1:
 sym_list[nodes[u].sym].code = ''.join(path)
 return
 path.append('0')
 dfs_build_codes(nodes[u].l, nodes, sym_list, path)
 path.pop()
 path.append('1')
 dfs_build_codes(nodes[u].r, nodes, sym_list, path)
 path.pop()

def build_huffman_codes(sym_list):
 n = len(sym_list)
 for sym in sym_list:
 sym.code = ''
 if n <= 0:
 return -1
 if n == 1:
 sym_list[0].code = '0'
 return 0
 nodes = []
 leaf_idx = []
 for i in range(n):
 leaf_idx.append(len(nodes))
 nodes.append(Node(sym_list[i].freq, -1, -1, i))
 leaf_idx.sort(key=lambda x: (nodes[x].w, nodes[x].sym))
 internal_idx = []
 pA = [0]
 pB = [0]
 for k in range(1, n):
 x = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
 y = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
 z = len(nodes)
 ______________________________
 root = internal_idx[-1] if internal_idx else -1
 path = []
 dfs_build_codes(root, nodes, sym_list, path)
 return root

if __name__ == "__main__":
 syms = [
 Symbol('A', 5),
 Symbol('B', 9),
 Symbol('C', 12),
 Symbol('D', 13),
 Symbol('E', 16),
 Symbol('F', 45)
 ]
 root = build_huffman_codes(syms)
 print(f"哈夫曼树根节点下标：{root}")
 for sym in syms:
 print(f"字符 '{sym.ch}' (频率 {sym.freq})：编码 {sym.code}")

以下关于哈夫曼编码的说法，正确的是（ ）。

以下函数实现了⼆叉排序树（BST）的（ ）操作。

class TreeNode:
 def __init__(self, val=0, left=None, right=None):
 self.val = val
 self.left = left
 self.right = right

def op(root, x):
 if not root:
 return TreeNode(x)

 if x < root.val: 
 root.left = op(root.left, x)
 else: 
 root.right = op(root.right, x)
 return root