Python 五级 2025 年 03 月
题号 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
答案 A A A B D B A D A D C A A D B
1 单选题（每题 2 分，共 30 分）
第 1 题 链表不具备的特点是( )。
A. 可随机访问任何一个元素
B. 插入、删除操作不需要移动元素
C. 无需事先估计存储空间大小
D. 所需存储空间与存储元素个数成正比
第 2 题 双向链表中每个结点有两个指针域 prev 和 next ，分别指向该结点的前驱及后继结点。设 p 指向链表中的一个结点，它的前驱结点和后继结点均非空。现要求删除结点 p ，则下述语句中错误的是（ ）。
A.class Node:
def init(self, value):
self.value = value
self.prev = None
self.next = None
if p.next:
p.next.prev = p.prev
if p.prev:
p.prev.next = p.next
p = None
B.
class Node:
def init(self, value):
self.value = value
self.prev = None
self.next = None
if p.next:
p.next.next = p.prev
if p.prev:
p.prev.next = p.next
p = None
C.
class Node:
def init(self, value):
self.value = value
self.prev = None
self.next = None
if p.next:
p.next.prev = p.prev
if p.prev:
p.prev.next = p.prev
p = None
D.
class Node:
def init(self, value):
self.value = value
self.prev = None
self.next = None
if p.next:
p.next.prev = p.next
if p.prev:
p.prev.next = p.next
p = None
第 3 题 假设双向循环链表包含头尾哨兵结点(不存储实际内容)，分别为 head 和 tail ，链表中每个结点有两个指针域 prev 和 next ，分别指向该结点的前驱及后继结点。下面代码实现了一个空的双向循环链表，横线上应填的最佳代码是( )。
class ListNode:
def init(self, val=None):
self.data = val
self.prev = None
self.next = None
class LinkedList:
def init(self):
self.head = ListNode()
self.tail = ListNode()
def init_linked_list():
return LinkedList()
A.
self.head.next = self.tail
self.tail.prev = self.head
B.
self.head.next = self.head
self.tail.prev = self.tail
C.
self.head.next = self.tail
self.tail.next = self.head
D.
self.head.prev = self.tail
self.tail.next = self.head
第 4 题 用以下辗转相除法（欧几里得算法）求gcd(84, 60)的步骤中，第二次调用gcd()函数计算的数是（ ）。
def gcd(a, b):
big = max(a, b)
small = min(a, b)
if big % small == 0:
return small
return gcd(small, big % small)
A. 84和60
B. 60和24
C. 24和12
D. 12和0
第 5 题 根据唯一分解定理，下面整数的唯一分解是正确的（ ）。
A. 18 = 3 × 6
B. 28 = 4 × 7
C. 36 = 2 × 3 × 6
D. 30 = 2 × 3 × 5
第 6 题 下述代码实现素数表的线性筛法，筛选出所有小于等于n的素数，横线上应填的最佳代码是( )。
def sieve_linear(n):
is_prime = [True] * (n + 1)
primes = []
if n < 2:
return primes #
is_prime[0] = is_prime[1] = False
for i in range(2, n // 2 + 1):
if is_prime[i]:
primes.append(i)
j = 0
is_prime[i * primes[j]] = False
if i % primes[j] == 0:
break
j += 1
for i in range(n // 2 + 1, n + 1):
if is_prime[i]:
primes.append(i)
return primes
A. while j < len(primes) and j * primes[j] <= n:
B. while j < len(primes) and i * primes[j] <= n:
C. while j < len(primes) and j * primes[i] <= n:
D. while i < len(primes) and i * primes[j] < n:
第 7 题 在程序运行过程中，如果递归调用的层数过多，会因为（ ）引发错误。
A. 系统分配的栈空间溢出
B. 系统分配的堆空间溢出
C. 系统分配的队列空间溢出
D. 系统分配的链表空间溢出
第 8 题 对下面两个函数，说法错误的是（ ）。
def factorialA(n):
if n <= 1:
return 1
return n * factorialA(n - 1)
def factorialB(n):
if n <= 1:
return 1
res = 1
for i in range(2, n + 1):
res *= i
return res
A. 两个函数的实现的功能相同。
B. 两个函数的时间复杂度均为 。
C. factorialA采用递归方式。
D. factorialB采用递归方式。
第 9 题 下算法中，（ ）是不稳定的排序。
A. 选择排序
B. 插入排序
C. 归并排序
D. 冒泡排序
第 10 题 考虑以下python代码实现的快速排序算法，将数据从小到大排序，则横线上应填的最佳代码是( )。
def partition(arr, low, high):
pivot = arr[high]
i = low - 1
for j in range(low, high):
arr[i + 1], arr[high] = arr[high], arr[i + 1]
return i + 1
def quick_sort(arr, low, high):
if low < high:
pi = partition(arr, low, high)
quick_sort(arr, low, pi - 1)
quick_sort(arr, pi + 1, high)
A.
if arr[i] < pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
B.
if arr[j] < pivot:
j += 1
C.
if arr[i] < pivot:
j += 1
arr[i], arr[i] = arr[j], arr[i]
D.
if arr[j] < pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
================================================
答案和更多内容请查看网站：【试卷中心 -----> CCF GESP ----> Python ----> 五级】
青少年软件编程历年真题模拟题实时更新
================================================