手写代码环节：测试面试中的编程题该怎么准备_千锋教育

01 为什么测试面试突然开始考编程？

测试行业正在经历一场无声的“技能通胀”。

2021年，一个功能测试岗的JD要求是“熟悉测试流程、会写用例、懂一点SQL”。2024年，同一个岗位的JD变成了“熟悉Python/Java、掌握数据结构与算法、能独立编写自动化脚本”。这不是个别公司的要求，而是整个行业的转向。

不会写代码的测试，正在被市场淘汰。

数据不会骗人。拉勾网统计显示，2024年Q1测试岗位中，明确要求“手写代码能力”的岗位占比达到67%，比2020年翻了3倍。薪资对比更扎心：能手写基础算法的测试工程师，平均薪资高出不会代码的同行42%。

为什么？因为企业发现了一个残酷的真相：不会写代码的测试，自动化率永远上不去。 你招一个只会点鼠标的测试，他最多能覆盖20%的回归测试；而一个能写代码的测试，能把自动化覆盖率拉到80%以上。人力成本一样，产出差4倍，企业用脚投票都知道选谁。

面试官考你手写代码，不是想为难你，而是在验证三件事：

1. 你是否有编程思维——能不能把业务逻辑转换成代码逻辑

2. 你的代码质量——变量命名、边界处理、异常捕获这些细节

3. 你的抗压能力——白纸写代码，没有IDE的智能提示，你能写多好

测试面试的编程题，考的不是算法难度，而是基本功的扎实程度。

---

02 测试面试必考的3类编程题

我分析了2024年300+份测试面试面经，发现测试岗的编程题集中在3个方向。掌握这3类，覆盖90%的面试场景。

第一类：字符串处理（出现率：78%）

这类题看似简单，但面试官最喜欢在这里挖坑。常见题型：

• ►反转字符串
• ►判断回文串
• ►统计字符出现次数
• ►字符串去重

面试官真正想看的不是你能不能写出来，而是你能不能处理边界情况。

来看一个真实面试题：“写一个函数，判断一个字符串是否是回文串，忽略空格和标点符号。”

def is_palindrome(s: str) -> bool:
    # 边界处理：空字符串
    if not s:
        return True
    
    # 双指针法
    left, right = 0, len(s) - 1
    
    while left < right:
        # 跳过非字母数字字符
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        
        # 比较字符（忽略大小写）
        if s[left].lower() != s[right].lower():
            return False
        
        left += 1
        right -= 1
    
    return True

这段代码看起来简单，但包含了3个面试官会打的得分点：

1. 空字符串处理

2. 双指针算法（O(n)时间复杂度）

3. 忽略非字母数字字符的细节

80%的候选人死在了边界处理上，而不是算法本身上。

第二类：数组与列表操作（出现率：65%）

测试工作中，数组操作是高频场景——处理测试数据、校验API返回结果、分析日志文件。面试官考这类题，就是在模拟实际工作场景。

高频题型：

• ►找出数组中的最大值/最小值
• ►数组去重
• ►两数之和
• ►合并两个有序数组

重点：写出一份“测试人员风格”的代码。

def find_duplicates(nums: list) -> list:
    """
    找出数组中所有重复元素
    参数：nums - 整数数组
    返回：重复元素列表
    示例：find_duplicates([1,2,3,2,4,3]) -> [2, 3]
    """
    if not nums:
        return []
    
    seen = set()
    duplicates = set()
    
    for num in nums:
        if num in seen:
            duplicates.add(num)
        else:
            seen.add(num)
    
    return list(duplicates)

注意看这段代码的注释——测试人员写的代码，注释必须是“测试用例风格”。面试官看到你写示例注释，就知道你有测试思维。

进阶技巧： 写完代码后，主动补充3个测试用例。

• ►正常情况：[1,2,3,2,4,3] → [2, 3]
• ►边界情况：[] → []
• ►极端情况：[1,1,1,1] → [1]

第三类：链表操作（出现率：45%）

为什么测试面试考链表？因为链表是理解“引用”和“指针”的最佳载体。测试自动化中，对象引用、DOM节点操作、数据库游标，底层都是链表思维。

高频题型：

• ►反转链表
• ►检测链表是否有环
• ►合并两个有序链表
• ►删除链表中的指定节点

面试官最爱的题：反转链表。

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverse_list(head: ListNode) -> ListNode:
    """
    反转单链表
    参数：head - 链表头节点
    返回：反转后的链表头节点
    示例：1->2->3->None 反转后 3->2->1->None
    """
    prev = None
    current = head
    
    while current:
        next_temp = current.next  # 保存下一个节点
        current.next = prev       # 反转指针
        prev = current            # 移动prev
        current = next_temp       # 移动current
    
    return prev

这道题的精髓在于：3个指针的移动顺序不能错。 面试官看你写这段代码，就看两件事：指针顺序对不对，边界处理有没有（空链表、单节点链表）。

---

03 3天速成：测试面试编程题备考方案

时间有限，别刷LeetCode的hard题。测试面试的编程题，考的是“会”不是“精”。3天时间，按这个节奏走。

第1天：掌握3种基础算法模式

模式1：双指针法

• ►适用场景：数组、字符串、链表
• ►核心思想：用两个指针遍历数据结构，一个快一个慢，或者一个左一个右
• ►练习题目：判断回文串、反转链表、两数之和

模式2：哈希表法

• ►适用场景：查找、去重、计数
• ►核心思想：用空间换时间，O(1)复杂度查找
• ►练习题目：数组去重、两数之和、统计字符频率

模式3：递归法

• ►适用场景：树、链表、分治问题
• ►核心思想：把大问题拆成小问题，找到递归终止条件
• ►练习题目：反转链表、合并有序链表、阶乘计算

99%的测试面试编程题，用这3种模式就能解决。

第2天：练习10道高频题

不要贪多，10道题足够。每道题写3遍：

1. 第一遍：看答案，理解思路

2. 第二遍：关掉答案，自己写

3. 第三遍：在白纸上手写，限时10分钟

推荐练习列表：

1. 反转字符串（双指针）

2. 判断回文串（双指针+边界处理）

3. 数组去重（哈希表）

4. 两数之和（哈希表）

5. 反转链表（双指针/递归）

6. 检测链表环（快慢指针）

7. 合并两个有序数组（双指针）

8. 括号匹配（栈）

9. 二分查找（边界处理）

10. 斐波那契数列（递归/迭代）

第3天：模拟面试+总结模板

找朋友或自己录视频，模拟面试场景。重点训练3个能力：

能力1：先想后写

面试官出题后，别急着动笔。先说思路：“这道题我打算用双指针法，时间复杂度O(n)，空间复杂度O(1)。先处理边界情况，比如空数组...”

能力2：边写边说

写代码的同时，解释你的每一步：“现在我在处理边界情况，如果数组为空，直接返回空列表。接下来我用哈希表存储已经遍历过的元素...”

能力3：写完验证

代码写完后，主动补充测试用例：“我来验证一下这个代码。输入[1,2,3,2,4,3]，预期输出[2,3]。遍历到第一个1，存入哈希表；遍历到2，存入；遍历到3，存入；遍历到第二个2，发现哈希表中已有2，加入结果集...”

最后，准备一个“万能模板”：

def solve_problem(input_data):
    """
    功能描述
    参数说明
    返回值说明
    示例：...
    """
    # Step 1: 边界处理
    if not input_data:
        return default_value
    
    # Step 2: 初始化数据结构
    result = []
    
    # Step 3: 核心逻辑
    for item in input_data:
        # 处理逻辑
        pass
    
    # Step 4: 返回结果
    return result

这个模板能帮你应对80%的面试题。面试官看到你写代码有结构、有注释、有边界处理，印象分直接拉满。

---

04 面试现场：3个让你拿offer的加分动作

动作1：主动问清楚需求

面试官出题后，不要直接写。问3个问题：

• ►“输入的数组是整数还是浮点数？”
• ►“有没有重复元素？重复元素怎么处理？”
• ►“如果输入为空，应该返回什么？”

这3个问题，展示了你测试人员的核心能力：需求澄清。 很多候选人死在这里——不确认需求直接写，写出来和预期不符，直接凉凉。

动作2：先写测试用例，再写代码

“我先写几个测试用例，确保理解正确。” 然后你在白纸上写：

输入：[1, 2, 3, 2, 4, 3]
预期输出：[2, 3]

输入：[]
预期输出：[]

输入：[1, 1, 1]
预期输出：[1]

面试官看到你写测试用例，眼睛会发光。测试人员面试，不写测试用例就是自废武功。

动作3：主动分析复杂度

写完代码后，主动说：“这段代码的时间复杂度是O(n)，空间复杂度是O(n)。如果面试官要求优化空间复杂度，可以用排序法，时间复杂度O(nlogn)，空间复杂度O(1)。”

这句话展示了你对算法的理解深度。大多数候选人写出来就完事了，你多说了这一句，就超过了80%的人。

面试不是考试，是展示你如何思考问题。

---

05 一个真实案例：从被拒到拿offer，他只做了3件事

我的朋友小王，2023年面试字节跳动测试岗，手写代码环节挂了。面试官出的题是“合并两个有序数组”，他写出来了，但面试官说“你的代码有bug”。

他的代码：

def merge(nums1, m, nums2, n):
    i = m - 1
    j = n - 1
    k = m + n - 1
    
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    
    while j >= 0:
        nums1[k] = nums2[j]
        j -= 1
        k -= 1

bug在哪？ 面试官指出：如果nums1的第一个元素比nums2的所有元素都大，这个代码没问题。但如果nums1的第一个元素比nums2的第一个元素小，代码会出错。因为nums1中可能还有未处理的元素。

修正后的代码：

def merge(nums1, m, nums2, n):
    i = m - 1
    j = n - 1
    k = m + n - 1
    
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    
    # 处理nums1中剩余的元素（实际上不需要，因为nums1已经在正确位置）
    # 但需要处理nums2中剩余的元素
    while j >= 0:
        nums1[k] = nums2[j]
        j -= 1
        k -= 1

这个bug，暴露了他对边界情况的理解不够。测试人员写代码，边界就是生命线。

小王复盘后，做了3件事：

1. 把10道高频题每道写了5遍，直到闭眼能写

2. 每次写完代码，主动写3个测试用例验证

3. 模拟面试10次，训练“先说思路再写代码”的习惯

3个月后，他拿到了字节的offer。面试官说：“你的代码不是最好的，但你的测试思维是最好的。”

---

编程题考的不是算法，是你的基本功。 掌握3种模式、练习10道题、做好3个加分动作，你就能在面试中脱颖而出。

别把时间花在刷难题上，把时间花在把简单题写完美上。 测试面试的编程题，从来不是考你能不能写出最优解，而是考你能不能写出正确的、可测试的、有边界处理的代码。

去写吧。白纸和笔，就是你最好的IDE。