首页 › 题库 › GESP编程能力等级认证 › GESP-Python六级

GESP-Python六级 题库

共 243 道题 ,第 2 / 13 页 · 按题型筛选,点「查看答案」核对解析
21 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

以下函数check()用于判断一棵二叉树是否为( )。

from collections import deque

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

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
A

满二叉树

B

完全二叉树

C

二叉搜索树

D

平衡二叉树

答案与解析
正确答案:B
函数通过层序遍历处理二叉树节点。初始化队列并将根节点入队。遍历过程中,从队列取出节点,若当前节点为空,设置标志表示已遇到空节点。若当前节点非空且空节点标志已设置,则后续逻辑基于节点存在性与队列操作继续推进。将当前节点的左右子节点依次加入队列,无论其是否为空。遍历持续直至队列为空。整个过程依据节点出队顺序、空节点出现时机及子节点入队规则进行。
题目详情
22 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

以下代码实现了二叉树的( )。

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)
A

前序遍历

B

中序遍历

C

后序遍历

D

层序遍历

答案与解析
正确答案:C
分析函数traverse的执行顺序:首先判断根节点是否存在,若不存在则直接返回;接着递归调用左子树,然后递归调用右子树,最后打印当前节点的值。该过程遵循先处理左子树、再处理右子树、最后访问根节点的顺序。观察函数中对左右子树的调用位置与根节点值输出的时间关系,可推断其遍历次序的特点。结合二叉树遍历定义,此种调用结构对应特定的遍历方式。
题目详情
23 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

下面代码实现了哈夫曼编码,则横线处应填写的代码是( )。

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] < n and (pB[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)
        # 补全缺失的构建内部节点代码(原代码空白处)
        nodes.append(Node(w=nodes[x].w + nodes[y].w, l=x, r=y, sym=-1))
        internal_idx.append(z)

    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}")
A
nodes.append(Node(nodes[x].w + nodes[y].w, x, y, -1)) 
internal_idx.append(z)
B
nodes.append(Node(nodes[x].w + nodes[y].w, x, y, 1)) 
internal_idx.append(z)
C
nodes.append(Node(nodes[x-1].w + nodes[y].w, x, y, 1)) 
internal_idx.append(z)
D
nodes.append(Node(nodes[x+1].w + nodes[y].w, x, y, 1)) 
internal_idx.append(z)
答案与解析
正确答案:A
分析符号频率并构建叶子节点,将所有叶子节点按权重加入待处理队列。每次从队列中选取权重最小的两个节点合并为新内部节点,新节点权重为其子节点权重之和,左右子节点分别指向被合并的两个节点,且该内部节点不关联具体字符。将新生成的内部节点加入节点集合,并记录其索引。重复此过程直至队列中仅剩一个节点,即哈夫曼树的根节点。在合并过程中需维护叶节点和内部节点的索引列表,确保每次取最小权重节点时能正确访问对应节点。
题目详情
24 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.2 哈夫曼树

以下关于哈夫曼编码的说法,正确的是( )。

A

哈夫曼编码是定长编码

B

哈夫曼编码中,没有任何一个字符的编码是另一个字符编码的前缀

C

哈夫曼编码一定唯一

D

哈夫曼编码不能用于数据压缩

答案与解析
正确答案:B
哈夫曼编码基于字符出现频率构建二叉树,频率越低的字符位于更深的叶节点。编码通过从根到叶路径生成,左分支标记0,右分支标记1,或反之。每个字符对应唯一路径,路径序列即为其编码。由于编码由叶节点决定,任意编码均无法通过另一条完整路径延伸得到,故一个字符的编码不会是另一个字符编码的前缀。构建过程中,不同合并顺序可能产生不同结构的二叉树,导致编码方案不唯一。编码长度随字符频率动态变化,非固定长度。该机制将高频字符映射为短码,低频字符映射为长码,整体编码长度趋于最小化。
题目详情
25 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念
以下函数实现了二叉排序树(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 &lt; root.val: 
        root.left = op(root.left, x) 
    else: 
        root.right = op(root.right, x) 
    return root
A

查找

B

插入

C

删除

D

遍历

答案与解析
正确答案:B
分析函数参数,识别递归结构与节点创建行为。观察函数在空节点时返回新节点,表明涉及结构修改。比较输入值与根节点值决定递归方向,左子树处理较小值,右子树处理较大值,符合二叉排序树的组织规则。递归调用嵌入赋值语句,更新左或右子树引用,体现自底向上传播的结构调整过程。无中序前驱或后继节点查找逻辑,未处理双子树非空的复杂情况,排除删除操作的可能性。函数未返回布尔类型或节点值,排除纯查找行为。遍历操作通常不改变树结构且会访问所有节点,与此函数仅沿单一路径深入的行为不符。
题目详情
26 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

下列代码实现了树的深度优先遍历,则横线处应填入( )。

class TreeNode: 
    def __init__(self, x): 
        self.val = x 
        self.left = None 
        self.right = None 
def dfs1(root): 
    if not root: 
        return 
    temp = [] 
    temp.append(root) 
    while temp: 
        node = temp[-1] 
        temp.pop() 
        print(node.val, end=" ") 
        if node.right: 
            temp.append(node.right) 
        if node.left: 
            temp.append(node.left) 
def dfs2(root): 
    if not root: 
        return 
    st = [] 
    st.append(root) 
    while st: 
        node = st[-1] 
        st.pop() 
        print(node.val, end=" ") 
        if node.right: 
            st.append(node.right) 
        ——————————————————


A
if node.left: 
    st.append(node.left)
B
if node.right: 
    st.append(node.left)
C
if node.left: 
    st.append(node.right)
D
if node.right: 
    st.append(node.right)
答案与解析
正确答案:A
分析代码逻辑,观察遍历过程中栈的使用方式。dfs1函数中先将右子节点压栈,再将左子节点压栈,导致左子节点先被弹出处理,实现的是根-左-右的访问顺序。dfs2函数结构与dfs1一致,已存在对右子节点的判断和压栈操作。为保持相同的遍历顺序,需在右子节点之后处理左子节点。栈为后进先出结构,因此后续入栈的左子节点将在下一轮循环中优先被访问。需补全对左子节点的条件判断及入栈操作,以维持与dfs1一致的处理流程。
题目详情
27 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

给定一棵普通二叉树(节点值没有大小规律),下面代码判断是否存在值为 x 的结点,则横线处应填入( )。

class TreeNode: 
    def __init__(self, x): 
        self.val = x 
        self.left = None 
        self.right = None 
from collections import deque 
def bfs_find(root, x): 
    if not root: 
        return None 
    q = deque() 
    q.append(root) 
    while q: 
        cur = q.popleft() 
        if cur.val == x: 
            return cur 
        ______________________ 
    return None
A
q.append(cur.left)
B
q.append(cur.right)
C
if cur.left: 
    q.append(cur.left) 
if cur.right: 
    q.append(cur.right)
D
if cur.right: 
    q.append(cur.left) 
if cur.left: 
    q.append(cur.right)
答案与解析
正确答案:C
使用队列实现广度优先搜索,从根节点开始逐层遍历。每次从队列头部取出一个节点,检查其值是否为目标值。若匹配,则返回该节点。否则,将其存在的左子节点和右子节点依次加入队列尾部,确保后续节点能按层次顺序被访问。遍历持续到队列为空,期间未找到目标值则最终返回None。需保证每个节点的左右子树在存在前提下被加入队列,以避免空引用错误并维持遍历完整性。
题目详情
28 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

在二叉排序树(Binary Search Tree, BST)中,假设节点值互不相同。给定如下搜索函数,以下说法 一定正确的是( )。

class Node: 
    def __init__(self, val=0, left=None, right=None): 
        self.val = val 
        self.left = left 
        self.right = right 
def find(root, x): 
    while root: 
        if root.val == x: 
            return True 
        if x &lt; root.val: 
            root = root.left 
        else: 
            root = root.right 
    return False
A

最坏情况下,访问结点数是 O(log n)

B

最坏情况下 ,访问结点数是O(n)

C

无论如何 ,访问结点数都不超过树高的一半

D

一定比在普通二叉树中搜索快

答案与解析
正确答案:B
分析二叉排序树的结构特性,搜索过程从根节点开始,根据目标值与当前节点值的大小关系决定向左子树或右子树移动。每一步比较后仅进入一个子树,路径唯一。访问的节点数等于搜索路径上的节点总数。树的高度由节点插入顺序决定,可能为平衡状态下的O(log n),也可能退化为链状结构时的O(n)。搜索过程中不进行回溯,也不访问无关分支。访问节点数取决于树的实际形态和目标值所在位置。
题目详情
29 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

0/1 背包(每件物品最多选一次) 问题通常可用一维动态规划求解 ,核心代码如下 。遍历的方向无所谓 ,则下面说法正确的是(  )。

def zero_one_knapsack(items, W): 
    dp = [0] * (W + 1) 
    for w, v in items: 
        for j in range(W, w - 1, -1): 
            dp[j] = max(dp[j], dp[j - w] + v) 
    return dp[W]
A

内层 j 必须从小到大,否则会漏解

B

内层 j 必须从大到小,否则同一件物品会被用多次

C

j 从大到小或从小到大都一样

D

只要 dp 初始为 0 ,方向无所谓

答案与解析
正确答案:B
动态规划数组 dp 表示容量为 j 时能获得的最大价值。每件物品仅可选择一次,更新状态时需确保当前物品的重量和价值不会基于本轮已更新的状态进行计算。内层循环遍历容量从 W 到 w,采用逆序确保每次状态转移依赖的是前一轮物品的 dp 值。若采用正序,则较小容量的状态先被更新,后续较大容量可能重复引用同一物品,导致物品被多次使用。逆序避免了当前轮次的状态覆盖对后续状态转移的影响。
题目详情
30 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

以下关于动态规划的说法中,错误的是( )。

A

动态规划方法通常能够列出递推公式。

B

动态规划方法的时间复杂度通常为状态的个数。

C

动态规划方法有递推和递归两种实现形式。

D

在使用动态规划思想(即避免重复子问题)的前提下,递推实现与递归实现(记忆化搜索)的时间复杂度通常是相当的。

答案与解析
正确答案:B
动态规划通过定义状态描述问题的子结构,建立状态之间的转移关系形成递推公式。状态数量决定计算过程中需要处理的子问题总数。实现时可采用自底向上的递推方式,按顺序求解每个状态;也可采用自顶向下的递归方式配合记忆化存储,避免重复计算相同状态。两种实现方式均覆盖全部必要子问题,访问的状态集合一致,执行的操作规模由状态空间和转移成本共同决定。算法的时间开销取决于状态总数与单个状态转移所需时间的乘积。
题目详情
31 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

关于Python类的说法,错误的是( )。

A

构造方法( __init__ )不能声明为虚方法,但析构方法( __del__ )可以。

B

函数参数传传递的是对象的引用,不会复制对象。

C

静态方法属于类、不属于对象,因此不能使用 对象.方法(...) 的形式调用静态方法。

D

当派生类对象被销毁时,不会自动调用基类的 __del__() 。

答案与解析
正确答案:C
这道题暂未补解析。
题目详情
32 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

下面代码执行结果是()。

A

Toyota is moving...

B

Toyota car is driving on the road!

C

编译错误

D

运行结果不确定

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
33 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

下面代码中 v1 和 v2 调用了相同接口 move() ,但输出结果不同,这体现了面向对象编程的( )特性。

A

继承 (Inheritance)

B

封装 (Encapsulation)

C

多态 (Polymorphism)

D

链接 (Linking)

答案与解析
正确答案:C
这道题暂未补解析。
题目详情
34 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.1 栈

栈的操作特点是( )。

A

先进先出

B

先进后出

C

随机访问

D

双端进出

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
35 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.2 队列

循环队列常用于实现数据缓冲。假设一个循环队列容量为 5(即最多存放 4 个元素,留一个位置区分空与满),依次进行操作:入队数据1,2,3,出队1个数据,再入队数据4和5,此时队首到队尾的元素顺序是( )。

A

[2, 3, 4, 5]

B

[1, 2, 3, 4]

C

[3, 4, 5, 2]

D

[2, 3, 5, 4]

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
36 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

以下函数 createTree() 构造的树是什么类型?

A

满二叉树

B

完全二叉树

C

二叉排序树

D

其他都不对

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
37 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

已知二叉树的 中序遍历 是 [D, B, E, A, F, C],先序遍历 是 [A, B, D, E, C, F]。请问该二叉树的后序遍历结果是( )。

A

[D, E, B, F, C, A]

B

[D, B, E, F, C, A]

C

[D, E, B, C, F, A]

D

[B, D, E, F, C, A]

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
38 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

完全二叉树可以用数组连续高效存储。如果节点从 1 开始编号,则对有两个孩子节点的节点 i ,()。

A

左孩子位于 2i ,右孩子位于 2i+1

B

完全二叉树的叶子节点可以出现在最后一层的任意位置

C

所有节点都有两个孩子

D

左孩子位于 2i+1 ,右孩子位于 2i+2

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
39 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

设有字符集 {a, b, c, d, e, f} ,其出现频率分别为 {5, 9, 12, 13, 16, 45} 。哈夫曼算法构造最优前缀编码,以下哪一组可能是对应的哈夫曼编码?(非叶子节点左边分支记作 0,右边分支记作 1,左右互换不影响正确性)。

A

a: 00;b: 01;c: 10;d: 110;e: 111;f: 0

B

a: 1100;b: 1101;c: 100;d: 101;e: 111;f: 0

C

a: 000;b: 001;c: 01;d: 10;e: 110;f: 111

D

a: 10;b: 01;c: 100;d: 101;e: 111;f: 0

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
40 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 2.1 格雷编码

下面代码生成格雷编码中, gray_code 的目的是生成所有的长度为n位的格雷码,则横线上应填写( )。

A

result.append("1" + s)

B

result.append("0" + s)

C

result.append("s" + 0)

D

result.append("0" + 0)

答案与解析
正确答案:B
这道题暂未补解析。
题目详情