GESP Python 5级 2025.09
以下哪种情况使用链表比数组更合适?
数据量固定且读多写少
需要频繁在中间或开头插入、删除元素
需要高效随机访问元素
存储空间必须连续
下面的python代码实现给定单链表头结点 head 和一个整数 val ,删除链表中所有结点值等于 val 的节点,并返回新的头结点,则横线处填写( )。
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def removeElements(head: ListNode, val: int) -> ListNode:
dummy = ListNode(0, head)
cur = dummy
while cur.next:
if cur.next.val == val:
——————————————————————————————————
del del_node
else:
cur = cur.next
return dummy.next
del_node = del_node.
cur.next = del_node.next
del_node = cur.next
cur = del_node.next
del_node = cur.next
cur.next = del_node.next
del_node = cur.next
cur.next = del_node
下列python代码用Floyd判断一个单链表中是否存在环,链表的头节点为 head ,即用两个指针在链表上前进: slow 每次走 1 步, fast 每次走 2 步,若存在环, fast 终会追上 slow (相遇);若无环, fast 会先到达 nullptr。横线上应填写( )。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def hasCycle(head: ListNode) -> bool:
if not head or not head.next:
return False
slow = head
fast = head.next
while fast and fast.next:
if slow == fast:
return True
_________________
return False
slow = slow.next
fast = fast.next.next
slow.next = slow
fast = fast.next.next
slow = slow.next
fast.next = fast.next.next
slow = slow.next
fast = fast.next
下列代码用于判断一个数是否为完全数(即等于它的真因子之和的数,如6=1+2+3),哪个选项是正确的实现?
def isPerfectNumber(n: int) -> bool:
if n <= 1:
return False
sum = 1
i = 2
while i * i <= n:
if n % i == 0:
sum += i
_______________
sum += n // i
i += 1
return sum == n
if i != n / i:
if i != n // i:
if i = n // i:
if i == n // i:
以下代码计算两个数的最大公约数(GCD),横线上应填写( )。
def gcd(a: int, b: int) -> int:
if a < b:
a, b = b, a # 交换a和b的值
while b != 0:
temp = a % b
a = b
b = temp
return _________
b
a
temp
a+b
下面的代码实现埃拉托斯特尼筛法(埃氏筛),横线处应填入( )。
def sieve(n: int):
is_prime = [True] * (n + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, n + 1):
if is_prime[i]:
for j in range(______, n + 1, i):
is_prime[j] = False
return is_prime
i
i+1
i*2
i*i
下面的代码实现线性筛法(欧拉筛),横线处应填入( )。
def linearSieve(n: int):
is_prime = [True] * (n + 1)
primes = []
for i in range(2, n + 1):
if is_prime[i]:
primes.append(i)
for p in primes:
if p * i > n:
break
is_prime[p * i] = False
if _____________:
break
return primes
i % p == 0
p % i == 0
i == p
i * p == n
线性筛算法中有语句 if p * i > n break; ,其目的是( )。
def linearSieve(n: int):
is_prime = [True] * (n + 1)
primes = []
for i in range(2, n + 1):
if is_prime[i]:
primes.append(i)
for p in primes:
if p * i > n:
break
is_prime[p * i] = False
if _____________:
break
return primes
降低常数但复杂度仍是
保证每个合数只被其最小质因子筛到一次,从而
提高缓存命中率,复杂度仍
不重要,是否 break 都一样
唯一分解定理描述的是( )。
每个整数都能表示为任意素数的乘积
每个大于 1 的整数能唯一分解为素数幂乘积(忽略顺序)
合数不能分解为素数乘积
素数只有两个因子:1 和自身
给定一个 n x n 的矩阵 matrix ,矩阵的每一行和每一列都按升序排列。下面代码返回矩阵中第 k 小的元素,则两处横线上应分别填写( )。
def countLE(matrix, x):
n = len(matrix)
i, j = n - 1, 0
cnt = 0
while i >= 0 and j = k:
________
else:
________
return lo
hi = mid - 1
lo = mid + 1
hi = mid
lo = mid
hi = mid
lo = mid + 1
hi = mid + 1
lo = mid
