[GESP202503 六级] 客观题

ID: 209

Type: Objective

Tried: 0

Accepted: 0

Difficulty: (None)

Uploaded By:

wzy

Tags>

GESP Python编程能力等级认证

单选题

在面向对象编程中，类是一种重要的概念。下面关于类的描述中，不正确的是（）。

{{ select(1) }}

类是一个抽象的概念，用于描述具有相同属性和行为的对象集合。
类可以包含属性和方法，属性用于描述对象的状态，方法用于描述对象的行为。
类可以被实例化，生成具体的对象。
类一旦定义后，其属性和方法不能被修改或扩展。

哈夫曼编码是一种用于数据压缩的算法。以下关于哈夫曼编码的描述中，不正确的是（）。

{{ select(2) }}

哈夫曼编码是一种变长编码，频率高的字符使用较短的编码，频率低的字符使用较长的编码。
在构造哈夫曼树时，频率越低的字符离根节点越近，频率越高的字符离根节点越远。
哈夫曼编码的生成过程基于贪心算法，每次选择频率最低的两个节点进行合并。
哈夫曼编码是一种前缀编码，任何一个字符的编码都不会是另一个字符编码的前缀，因此可以实现唯一解码。

以下代码实现了树的哪种遍历方式？

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

前序遍历
中序遍历
后序遍历
层次遍历

以下关于完全二叉树的代码描述，正确的是（）。

def is_complete_tree(root):
    if root is None:
        return True
    q = deque()
    q.append(root)
    has_null = False
    while q:
        node = q.popleft()
        if node is None:
            has_null = True
        else:
            if has_null:
                return False
            q.append(node.left)
            q.append(node.right)
    return True

该代码用于判断一棵树是否为满二叉树
该代码用于判断一棵树是否为完全二叉树
该代码用于判断一棵树是否为二叉搜索树
该代码用于计算树的高度

以下代码实现了二叉排序的哪种操作？

def op(root, val):
    if root is None:
        return TreeNode(val)
    if val < root.val:
        root.left = op(root.left, val)
    else:
        root.right = op(root.right, val)
    return root

查找
插入
删除
遍历

给定字符集 {A, B, C, D} 的出现频率分别为 {5, 1, 6, 2}, 则正确的哈夫曼编码是（）。

{{ select(6) }}

A: 0, B: 100, C: 11, D: 101
A: 11, B: 100, C: 0, D: 101
A: 0, B: 101, C: 11, D: 100
A: 10, B: 101, C: 0, D: 100

关于动态规划的描述，正确的是（）。

{{ select(7) }}

动态规划算法的时间复杂度总是低于贪心算法。
动态规划要求问题必须具有最优子结构和重叠子问题两个性质。
动态规划通过递归实现时不需要存储中间结果。
动态规划的核心思想是将问题分解为互不重叠的子问题。

以下代码中，类的构造函数被调用了（）次。
```
obj1 = MyClass()
obj2 = copy.deepcopy(obj1)
```
{{ select(8) }}

以下代码中function()实现了循环队列的哪种操作？

def function1(self, value):
    if self.is_full():
        return False
    if self.is_empty():
        self.front = 0
    self.rear = (self.rear + 1) % self.size
    self.arr[self.rear] = value
    return True

入队
出队
查看队首元素
判断队列是否为空

以下代码实现了二叉树的深度优先搜索（DFS），并统计了叶子节点的数量。横线上应填写（）。

while stack:
    node = stack.pop()
    if node.left is None and node.right is None:
        count += 1
    if node.right:
        stack.append(node.right)
    if node.left:
        ______

stack.append(node.left)
stack.append(node.right)
stack.delete(node.left)
stack.delete(node.right)

以下代码实现了二叉树的广度优先搜索（BFS），并查找特定值的节点。横线上应填写（）。
```
while q:
    current = q.popleft()
    if current.val == target:
        return current
    ______
```
{{ select(11) }}

if current.left:
    q.append(current.right)
if current.right:
    q.append(current.left)

if current.left:
    q.append(current.left)
if current.right:
    q.append(current.right)

if current.left:
    q.append(current)
if current.right:
    q.append(current.right)

if current.left:
    q.append(current.left)
if current.right:
    q.append(current)

以下代码用于生成n位格雷编码。横线上应填写（）。
```
prev = generate_gray_code(n - 1)
result = ["0" + s for s in prev]
return result
```
{{ select(12) }}

result += ["1" + s for s in reversed(prev)]
result += ["0" + s for s in reversed(prev)]
result += ["1" + s for s in reversed(1)]
result += ["1" + s for s in reversed(0)]

以下代码实现了0/1背包问题的动态规划解法。假设物品重量为weights[]，价值为values[]，背包容量为M，横线上应填写（）。
```
if weights[i - 1] > j:
    dp[i][j] = dp[i - 1][j]
else:
    dp[i][j] = max(______)
```
{{ select(13) }}

dp[i][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]
dp[i - 1][j], dp[i][j - weights[i - 1]] + values[i - 1]
dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]
dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]

以下代码用于检查字符串中的括号是否匹配，横线上应填写（）。

for c in s:
    if c in '([{':
        stack.append(c)
    else:
        if not stack:
            return False
        top = stack.pop()
        if (c == ')' and top != '(') or \
           (c == ']' and top != '[') or \
           (c == '}' and top != '{'):
            return False

True
False
return stack
return not stack

给定一个二叉排序树（BST），其中节点的值均为正整数。以下关于BST的说法中，错误的是：

{{ select(15) }}

对BST进行中序遍历，得到的序列一定是有序的。
在BST中查找一个值为x的节点，最坏情况下需要遍历整棵树。
向BST中插入一个新节点，可能会破坏BST的平衡性。
删除BST中的一个节点后，树的高度一定不会增加。

判断题

哈夫曼树在构造过程中，每次合并权值最小的两个节点，最终生成的树带权路径和最小。

{{ select(16) }}

格雷编码的相邻两个编码之间必须有多位不同，以避免数据传输错误。

{{ select(17) }}

在树的深度优先搜索（DFS）中，使用队列作为辅助数据结构以实现"先进后出"的访问顺序。

{{ select(18) }}

以下代码实现的是一文树的中序遍历：

def traverse(root):
    if root is None:
        return
    traverse(root.left)
    print(root.val, end=" ")
    return next node.

python可以直接定义多个构造函数，但默认无参数的构造函数只能有一个。

{{ select(20) }}

二叉排序树（BST）中，若某节点的左子树为空，则该节点一定是树中的最小值节点。

{{ select(21) }}

在动态规划解决一维硬币找零问题时，若硬币面额为 ([1, 3, 4])，目标金额为 6，则最少需要2枚硬币（3+3）。

{{ select(22) }}

面向对象编程中，封装是指将数据和行为绑定在一起，并对外隐藏实现细节。

{{ select(23) }}

以下代码创建的树是一棵完全二叉树：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)

栈和队列均可以用双向链表实现，插入和删除操作的时间复杂度为 (O(1))。

{{ select(25) }}

#G6205. [GESP202503 六级] 客观题

单选题

判断题

Status

Development

Support

About