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

GESP-Python六级 题库

共 243 道题 ,第 4 / 13 页 · 按题型筛选,点「查看答案」核对解析
61 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

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

A
类是一个抽象的概念,用于描述具有相同属性和行为的对象集合。
B
类可以包含属性和方法,属性用于描述对象的状态,方法用于描述对象的行为。
C
类可以被实例化,生成具体的对象。
D
类一旦定义后,其属性和方法不能被修改或扩展。
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
62 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.2 哈夫曼树

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

A
哈夫曼编码是一种变长编码,频率高的字符使用较短的编码,频率低的字符使用较长的编码。
B
在构造哈夫曼树时,频率越低的字符离根节点越近,频率越高的字符离根节点越远。
C
哈夫曼编码的生成过程基于贪心算法,每次选择频率最低的两个节点进行合并。
D
哈夫曼编码是一种前缀编码,任何一个字符的编码都不会是另一个字符编码的前缀,因此可以实现唯一解码。
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
63 单选题 适中 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 root is None:
		return
	print(root.val, end=" ")
	traverse(root.left)
	traverse(root.right)
A
前序遍历
B
中序遍历
C
后序遍历
D
层次遍历
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
64 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

以下关于完全二叉树的代码描述,正确的是( )。

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 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
A
该代码用于判断一棵树是否为满二叉树
B
该代码用于判断一棵树是否为完全二叉树
C
该代码用于判断一棵树是否为二叉搜索树
D
该代码用于计算树的高度
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
65 单选题 适中 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 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
遍历
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
66 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.2 哈夫曼树

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

A
A: 0, B: 100, C: 11, D: 101
B
A: 11, B: 100, C: 0, D: 101
C
A: 0, B: 101, C: 11, D: 100
D
A: 10, B: 101, C: 0, D: 100
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
67 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

关于动态规划的描述,正确的是( )。

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

动态规划的核心思想是将问题分解为互不重叠的子问题。

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

以下代码中,类的构造函数被调用了( )次。

import copy
class MyClass:
	def __init__(self):
		print("Constructor called!")
if __name__ == "__main__":
	obj1 = MyClass()
	obj2 = copy.deepcopy(obj1)
A
1
B
2
C
3
D
0
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
69 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 5.1 面向对象思想

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

class CircularQueue:
	def __init__(self, k):
		self.size = k
		self.arr = [0] * k
		self.front = -1
		self.rear = -1

	def is_full(self):

		return (self.rear + 1) % self.size == self.front

	def is_empty(self):

		return self.front == -1

	def fuction1(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
A
入队
B
出队
C
查看队首元素
D
判断队列是否为空
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
70 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

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

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

def count_leaf_nodes(root):
	if root is None:
		return 0

	stack = []
	stack.append(root)
	count = 0

	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:
			_______________________
	return count
A
stack.append(node.left)
B
stack.append(node.right)
C
stack.delete(node.left)
D
stack.delete(node.right)
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
71 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

以下代码实现了二叉树的广度优先搜索(BFS),并查找特定值的节点。横线上应填写( )。

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 find_node(root, target):
	if root is None:
		return None

	q = deque()
	q.append(root)
	
	while q:
		current = q.popleft()

		if current.val == target:
			return current
	__________________
	return None
A
if current.left:
	q.append(current.right)
if current.right:
	q.append(current.left)
B
if current.left:
	q.append(current.left)
if current.right:
	q.append(current.right)
C
if current.left:
	q.append(current)
if current.right:
	q.append(current.right)
D
if current.left:
	q.append(current.left)
if current.right:
	q.append(current)
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
72 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 2.1 格雷编码

以下代码用于生成 位格雷编码。横线上应填写( )。

def generate_gray_code(n):
	if n == 0:
		return ["0"]
	if n == 1:
		return ["0", "1"]

	prev = generate_gray_code(n - 1)

	result = ["0" + s for s in prev]
	__________________________________

	return result
A
result += ["1" + s for s in reversed(prev)]
B
result += ["0" + s for s in reversed(prev)]
C
result += ["1" + s for s in reversed(1)]
D
result += ["1" + s for s in reversed(0)]
答案与解析
正确答案:A
这道题暂未补解析。
题目详情
73 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 4.1 一维动态规划

以下代码实现了0/1背包问题的动态规划解法。假设物品重量为 weights[] ,价值为 values[] ,背包容量为 W ,横线上应填写( )。

def knapsack(W, weights, values):
	n = len(weights)
	dp = [[0] * (W + 1) for _ in range(n + 1)]

	for i in range(1, n + 1):
		for j in range(1, W + 1):
			if weights[i - 1] > j:
				dp[i][j] = dp[i - 1][j]
			else:
				dp[i][j] = max(__________________________________)
	return dp[n][W]
A
dp[i][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]
B
dp[i - 1][j], dp[i][j - weights[i - 1]] + values[i - 1]
C
dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]
D
dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]
答案与解析
正确答案:C
这道题暂未补解析。
题目详情
74 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 6.1 栈

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

def is_balanced(s):
	stack = []
	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
	__________________
A
True
B
False
C
return stack
D
return not stack
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
75 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

给定一个二叉排序树(BST),其中节点的值均为正整数。以下关于BST的说法中,错误的是:

A
对BST进行中序遍历,得到的序列一定是有序的。
B
在BST中查找一个值为k的节点,最坏情况下需要遍历整棵树。
C
向BST中插入一个新节点,可能会破坏BST的平衡性。
D
删除BST中的一个节点后,树的高度一定不会增加。
答案与解析
正确答案:D
这道题暂未补解析。
题目详情
76 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

关于哈夫曼树,下面说法正确的是( )。

A
不可能是满二叉树
B
哈夫曼树是一种用于数据压缩的二叉树
C
权值较大的结点离根较远
D
构建哈夫曼树的时间复杂度为O(logn)
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
77 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 综合练习

给定一组权值{3, 4, 7, 14, 15, 20},计算带其权路径长度(WPL)为( )。

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

二叉树T,已知其先根遍历是 1 2 4 3 5 7 6(数字为结点的编号,以下同),中根遍历是 2 4 1 5 7 3 6,则该二叉树的后根遍历是( )。

A
4 2 5 7 6 3 1
B
4 2 7 5 6 3 1
C
7 4 2 5 6 3 1
D
4 2 7 6 5 3 1
答案与解析
正确答案:B
这道题暂未补解析。
题目详情
79 单选题 适中 GESP编程能力等级认证 ·GESP-Python六级 · 1.1 树的基本概念

一棵二叉树的前序遍历序列是 ABCDEFG,后序遍历序列是 CBFEGDA,则根结点的左子树的结点个数可能是( )。

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

完全二叉树的顺序存储方案,是指将完全二叉树的结点从上至下、从左至右依次存放到一个顺序结构的数组中。假定根结点存放在数组的 1 号位置,则第 k 号结点的父结点如果存在的话,应当存放在数组的( )号位置。

A
2k
B
2k+1
C
⌊k/2⌋
D
⌊(k+1)/2⌋
答案与解析
正确答案:C
这道题暂未补解析。
题目详情