lnstagram优选1. 董付国老师Python小屋编程题131-140解析
作为一名Python开发者，我经常通过解决编程题来提升自己的编码能力。董付国老师的Python小屋系列题目以其贴近实际、难度适中的特点，在Python学习圈内广受欢迎。今天我想和大家分享131-140这10道编程题的解题思路和实现方法，这些题目覆盖了字符串处理、算法优化、面向对象编程等多个Python核心知识点。
在开始具体题目之前，我想先说明一下这些题目的特点：它们都不是简单的语法练习题，而是需要结合实际问题进行适当抽象和算法设计的综合性题目。每道题都有多种解法，我会尽量展示不同的实现思路，并分析各自的优缺点。对于刚接触Python不久的学习者，这些题目能很好地帮助理解Python的特性；对于有一定经验的开发者，也能从中获得启发。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 题目131：字符串加密与解密
2.1 题目要求分析
这道题要求实现一个简单的字符串加密解密系统。具体要求是：编写一个函数，能够将输入的字符串按照特定规则加密，同时也能将加密后的字符串解密还原。加密规则是将每个字符的ASCII码值加上其在字符串中的位置（从0开始）作为偏移量。
例如：
- 加密"hello"：
h(104) + 0 → 104 → 'h'
e(101) + 1 → 102 → 'f'
l(108) + 2 → 110 → 'n'
l(108) + 3 → 111 → 'o'
o(111) + 4 → 115 → 's'
加密结果："hfnos"
2.2 加密函数实现
python复制def encrypt(text):
encrypted = []
for i, char in enumerate(text):
new_ascii = ord(char) + i
encrypted.append(chr(new_ascii))
return ''.join(encrypted)
这个实现使用了Python的enumerate函数来同时获取字符和其索引位置，代码简洁明了。ord()函数获取字符的ASCII码值，chr()函数将ASCII码转换回字符。
2.3 解密函数实现
解密是加密的逆过程，需要将每个字符的ASCII码值减去其在字符串中的位置：
python复制def decrypt(encrypted_text):
decrypted = []
for i, char in enumerate(encrypted_text):
original_ascii = ord(char) - i
decrypted.append(chr(original_ascii))
return ''.join(decrypted)
2.4 边界情况处理
在实际应用中，我们需要考虑一些边界情况：
- 空字符串输入
- 包含非ASCII字符的情况
- 加密后字符超出可打印ASCII范围的情况
改进后的版本：
python复制def encrypt_safe(text):
if not text:
return ""
encrypted = []
for i, char in enumerate(text):
try:
new_ascii = ord(char) + i
# 确保结果在可打印ASCII范围内(32-126)
new_ascii = 32 + (new_ascii - 32) % 95
encrypted.append(chr(new_ascii))
except TypeError:
encrypted.append(char)
return ''.join(encrypted)
def decrypt_safe(encrypted_text):
if not encrypted_text:
return ""
decrypted = []
for i, char in enumerate(encrypted_text):
try:
original_ascii = ord(char) - i
# 同样需要处理范围
original_ascii = 32 + (original_ascii - 32) % 95
decrypted.append(chr(original_ascii))
except TypeError:
decrypted.append(char)
return ''.join(decrypted)
3. 题目132：矩阵旋转90度
3.1 问题描述
这道题要求编写一个函数，能够将给定的n×n矩阵顺时针旋转90度。要求在原矩阵上修改，不返回新矩阵。
例如：
输入矩阵：
[
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
旋转后应为：
[
[7, 4, 1],
[8, 5, 2],
[9, 6, 3]
]
3.2 解决方案分析
矩阵旋转可以通过两种方式实现：
- 转置后反转每一行
- 分层旋转，从外到内逐层处理
方法一：转置加反转
python复制def rotate_matrix(matrix):
n = len(matrix)
# 转置矩阵
for i in range(n):
for j in range(i, n):
matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
# 反转每一行
for row in matrix:
row.reverse()
这种方法利用了数学性质：顺时针旋转90度等于转置后行反转。时间复杂度为O(n²)，空间复杂度为O(1)。
方法二：分层旋转
python复制def rotate_matrix_layer(matrix):
n = len(matrix)
for layer in range(n // 2):
first = layer
last = n - 1 - layer
for i in range(first, last):
offset = i - first
# 保存上边
top = matrix[first][i]
# 左到上
matrix[first][i] = matrix[last-offset][first]
# 下到左
matrix[last-offset][first] = matrix[last][last-offset]
# 右到下
matrix[last][last-offset] = matrix[i][last]
# 上到右
matrix[i][last] = top
这种方法更直观地模拟了旋转过程，从外层开始，一层层向内旋转。虽然时间复杂度也是O(n²)，但在处理大型矩阵时可能更高效。
3.3 测试用例
python复制def test_rotate_matrix():
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
expected = [
[7, 4, 1],
[8, 5, 2],
[9, 6, 3]
]
rotate_matrix(matrix)
assert matrix == expected
# 测试4x4矩阵
matrix4 = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]
expected4 = [
[13, 9, 5, 1],
[14, 10, 6, 2],
[15, 11, 7, 3],
[16, 12, 8, 4]
]
rotate_matrix(matrix4)
assert matrix4 == expected4
4. 题目133：二叉树的右视图
4.1 问题理解
这道题要求给定一棵二叉树，返回从右侧看这棵树时能看到的节点值。换句话说，返回每一层最右边的节点。
例如：
1
/
2 3
\
5 4
右视图应该是[1, 3, 4]
4.2 广度优先搜索解法
最直观的方法是使用层次遍历（BFS），记录每一层的最后一个节点：
python复制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 right_side_view(root):
if not root:
return []
result = []
queue = deque([root])
while queue:
level_size = len(queue)
for i in range(level_size):
node = queue.popleft()
if i == level_size - 1:
result.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return result
4.3 深度优先搜索解法
也可以使用DFS，按照根->右->左的顺序遍历，并记录每个深度第一次访问的节点：
python复制def right_side_view_dfs(root):
result = []
def dfs(node, depth):
if not node:
return
if depth == len(result):
result.append(node.val)
dfs(node.right, depth + 1)
dfs(node.left, depth + 1)
dfs(root, 0)
return result
4.4 复杂度分析
两种方法的时间复杂度都是O(n)，需要访问所有节点。空间复杂度在最坏情况下（树退化为链表）也是O(n)。
BFS方法更适合宽树，DFS方法更适合深树。在实际应用中，可以根据树的形状选择更合适的方法。
5. 题目134：设计LRU缓存
5.1 LRU缓存概念
LRU（Least Recently Used）是一种常见的缓存淘汰策略，当缓存空间不足时，淘汰最近最少使用的项目。
题目要求设计并实现一个LRU缓存类，需要支持以下操作：
- 初始化时指定缓存容量
- get(key)：如果key存在则返回value，否则返回-1
- put(key, value)：如果key存在则更新value，否则添加。如果缓存已满，则淘汰最近最少使用的项目
5.2 使用OrderedDict实现
Python的collections.OrderedDict可以方便地实现LRU：
python复制from collections import OrderedDict
class LRUCache:
def __init__(self, capacity):
self.capacity = capacity
self.cache = OrderedDict()
def get(self, key):
if key not in self.cache:
return -1
self.cache.move_to_end(key)
return self.cache[key]
def put(self, key, value):
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
if len(self.cache) > self.capacity:
self.cache.popitem(last=False)
5.3 手动实现双向链表+哈希表
为了更深入理解原理，我们可以手动实现：
python复制class DLinkedNode:
def __init__(self, key=0, value=0):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCacheManual:
def __init__(self, capacity):
self.capacity = capacity
self.size = 0
self.cache = {}
self.head, self.tail = DLinkedNode(), DLinkedNode()
self.head.next = self.tail
self.tail.prev = self.head
def _add_node(self, node):
node.prev = self.head
node.next = self.head.next
self.head.next.prev = node
self.head.next = node
def _remove_node(self, node):
prev = node.prev
new = node.next
prev.next = new
new.prev = prev
def _move_to_head(self, node):
self._remove_node(node)
self._add_node(node)
def _pop_tail(self):
res = self.tail.prev
self._remove_node(res)
return res
def get(self, key):
node = self.cache.get(key, None)
if not node:
return -1
self._move_to_head(node)
return node.value
def put(self, key, value):
node = self.cache.get(key)
if not node:
new_node = DLinkedNode(key, value)
self.cache[key] = new_node
self._add_node(new_node)
self.size += 1
if self.size > self.capacity:
tail = self._pop_tail()
del self.cache[tail.key]
self.size -= 1
else:
node.value = value
self._move_to_head(node)
5.4 性能比较
OrderedDict实现简洁但效率略低，手动实现更高效但代码复杂。在实际项目中，如果性能不是关键因素，推荐使用OrderedDict版本。
6. 题目135：字符串的全排列
6.1 问题描述
给定一个字符串，输出其所有可能的排列组合，不能有重复。
例如："abc"的全排列为：
["abc", "acb", "bac", "bca", "cab", "cba"]
6.2 回溯算法实现
python复制def permute_unique(s):
def backtrack(first=0):
if first == n:
result.append("".join(s_list))
return
used = set()
for i in range(first, n):
if s_list[i] in used:
continue
used.add(s_list[i])
s_list[first], s_list[i] = s_list[i], s_list[first]
backtrack(first + 1)
s_list[first], s_list[i] = s_list[i], s_list[first]
n = len(s)
s_list = list(s)
result = []
backtrack()
return result
6.3 使用itertools实现
Python标准库提供了permutations函数，但需要自己处理重复和转换为字符串：
python复制from itertools import permutations
def permute_unique_itertools(s):
return list({"".join(p) for p in permutations(s)})
6.4 性能考虑
回溯算法在字符串较长时会有性能问题，因为全排列的数量是n!。对于n>10的情况，可能需要考虑其他方法或限制输出数量。
7. 题目136：寻找峰值元素
7.1 问题描述
峰值元素是指其值大于左右相邻值的元素。给定一个输入数组nums，其中nums[i] ≠ nums[i+1]，找到任何一个峰值元素并返回其索引。数组可能包含多个峰值，返回任何一个即可。要求时间复杂度为O(log n)。
7.2 二分查找解法
虽然数组未排序，但仍可以使用二分查找：
python复制def find_peak_element(nums):
left, right = 0, len(nums) - 1
while left < right:
mid = (left + right) // 2
if nums[mid] > nums[mid + 1]:
right = mid
else:
left = mid + 1
return left
7.3 算法正确性分析
这个算法利用了峰值必然存在的性质（边界视为负无穷）。每次比较中间元素与其右侧元素：
- 如果中间元素大于右侧，则峰值在左侧（包括中间）
- 否则峰值在右侧
这样每次都能将搜索范围减半，达到O(log n)的时间复杂度。
7.4 测试用例
python复制def test_find_peak():
assert find_peak_element([1, 2, 3, 1]) in [2]
assert find_peak_element([1, 2, 1, 3, 5, 6, 4]) in [1, 5]
assert find_peak_element([1]) == 0
assert find_peak_element([2, 1]) == 0
assert find_peak_element([1, 2]) == 1
8. 题目137：Z字形变换
8.1 问题描述
将给定字符串按照指定的行数进行Z字形排列，然后按行读取得到新字符串。
例如：
输入："PAYPALISHIRING", 行数=3
排列为：
P A H N
A P L S I I G
Y I R
输出："PAHNAPLSIIGYIR"
8.2 模拟Z字形遍历
python复制def convert(s, num_rows):
if num_rows == 1:
return s
rows = [[] for _ in range(num_rows)]
current_row = 0
going_down = False
for char in s:
rows[current_row].append(char)
if current_row == 0 or current_row == num_rows - 1:
going_down = not going_down
current_row += 1 if going_down else -1
result = []
for row in rows:
result.extend(row)
return "".join(result)
8.3 数学规律法
也可以找出字符在每行出现的规律：
python复制def convert_math(s, num_rows):
if num_rows == 1:
return s
cycle = 2 * num_rows - 2
result = []
n = len(s)
for i in range(num_rows):
for j in range(0, n - i, cycle):
result.append(s[j + i])
if i != 0 and i != num_rows - 1 and j + cycle - i < n:
result.append(s[j + cycle - i])
return "".join(result)
8.4 方法比较
模拟法更直观易懂，数学法效率略高但不易理解。在实际应用中，除非性能是关键因素，否则推荐使用模拟法。
9. 题目138：最长连续序列
9.1 问题描述
给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为O(n)。
例如：
输入：[100, 4, 200, 1, 3, 2]
最长连续序列是[1, 2, 3, 4]，长度为4
9.2 哈希集合解法
python复制def longest_consecutive(nums):
num_set = set(nums)
longest_streak = 0
for num in num_set:
if num - 1 not in num_set:
current_num = num
current_streak = 1
while current_num + 1 in num_set:
current_num += 1
current_streak += 1
longest_streak = max(longest_streak, current_streak)
return longest_streak
9.3 算法分析
这个算法的关键在于只从序列的起始点开始计数（即num-1不在集合中的点），这样每个元素最多被访问两次（一次在集合中检查，一次在内部循环中），总体时间复杂度为O(n)。
9.4 测试用例
python复制def test_longest_consecutive():
assert longest_consecutive([100, 4, 200, 1, 3, 2]) == 4
assert longest_consecutive([0, 3, 7, 2, 5, 8, 4, 6, 0, 1]) == 9
assert longest_consecutive([]) == 0
assert longest_consecutive([1]) == 1
assert longest_consecutive([1, 3, 5]) == 1
10. 题目139：单词拆分
10.1 问题描述
给定一个非空字符串s和一个包含非空单词列表的字典wordDict，判断s是否可以被拆分为一个或多个字典中的单词。字典中的单词可以重复使用。
例如：
s = "leetcode", wordDict = ["leet", "code"]
返回True，因为"leetcode"可以拆分为"leet code"
10.2 动态规划解法
python复制def word_break(s, wordDict):
word_set = set(wordDict)
n = len(s)
dp = [False] * (n + 1)
dp[0] = True
for i in range(1, n + 1):
for j in range(i):
if dp[j] and s[j:i] in word_set:
dp[i] = True
break
return dp[n]
10.3 算法解释
dp[i]表示s的前i个字符能否被拆分。我们遍历所有可能的拆分点j，如果前j个字符可以拆分且s[j:i]在字典中，则前i个字符可以拆分。
10.4 优化考虑
对于长字符串，可以首先找出字典中单词的最大长度，在内部循环时限制j的范围：
python复制def word_break_optimized(s, wordDict):
word_set = set(wordDict)
max_len = max(len(word) for word in wordDict) if wordDict else 0
n = len(s)
dp = [False] * (n + 1)
dp[0] = True
for i in range(1, n + 1):
start = max(0, i - max_len - 1)
for j in range(start, i):
if dp[j] and s[j:i] in word_set:
dp[i] = True
break
return dp[n]
11. 题目140：环形链表检测
11.1 问题描述
给定一个链表，判断链表中是否有环。要求使用O(1)空间复杂度解决。
11.2 快慢指针解法
python复制class ListNode:
def __init__(self, x):
self.val = x
self.next = None
def has_cycle(head):
if not head or not head.next:
return False
slow = head
fast = head.next
while slow != fast:
if not fast or not fast.next:
return False
slow = slow.next
fast = fast.next.next
return True
11.3 算法正确性
快指针每次移动两步，慢指针每次移动一步。如果有环，快指针最终会追上慢指针；如果无环，快指针会先到达链表尾部。
11.4 扩展问题
如果还需要找出环的起点，可以在相遇后将慢指针移回起点，然后两个指针都以一步速度前进，再次相遇点即为环起点：
python复制def detect_cycle(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
slow = head
while slow != fast:
slow = slow.next
fast = fast.next
return slow
return None
12. 解题经验总结
在完成这10道编程题的过程中，我积累了一些有价值的经验：
-
理解问题比编码更重要：在开始编码前，一定要彻底理解题目要求，包括边界条件和特殊情况的处理。比如在LRU缓存问题中，需要考虑容量为0的情况；在字符串加密问题中，需要考虑非ASCII字符的处理。
-
多种解法比较：很多问题都有多种解决方法，比如矩阵旋转可以用转置+反转或分层旋转。了解不同方法的优缺点有助于在实际应用中选择最合适的方案。
-
测试驱动开发：编写测试用例不仅能验证代码正确性，还能帮助理解问题。我在解决每个问题时都会先考虑各种可能的输入情况，包括空输入、极端值等。
-
空间与时间权衡：有些问题可以通过增加空间复杂度来降低时间复杂度，比如在最长连续序列问题中使用哈希集合来达到O(n)时间复杂度。在实际应用中需要根据具体场景做出权衡。
-
Python特性利用：合理使用Python的内置函数和数据结构可以简化代码，如使用OrderedDict实现LRU缓存，使用itertools生成排列组合等。但也要注意这些高级抽象的潜在性能开销。
-
算法可视化：对于复杂的算法如Z字形变换、环形链表检测等，画图辅助理解可以大大提高解题效率。我在解决这些问题时都会先在纸上画出示例的运行过程。
-
边界条件优先：在编写代码时，优先考虑边界条件（如空输入、单个元素等）的处理，这样可以避免很多潜在的错误。
通过这组编程题的练习，我对Python的数据结构、算法设计有了更深入的理解，也积累了更多解决实际问题的经验。这些题目虽然看似独立，但很多解题思路是可以相互借鉴的，比如回溯法可以用于排列组合问题，也可以应用于其他需要穷举的场景；快慢指针技巧不仅适用于环形链表检测，也可以用于解决其他链表相关问题。