华为机试题实战：5个高频面试题代码解析与避坑指南

看了一堆教程还是不会写项目？别急，问题往往出在练习方式上。华为机试不是背题，而是考察你能否在限定时间内解决实际问题。这里整理了5道高频面试题，带你从零搭建解题框架，直接上手写代码。

项目目标

这次实战的目标很明确：通过5道典型题目，掌握华为机试的常见题型和解题思路。你会学到如何快速分析题意、设计算法、编写代码并测试验证。

具体要达成的能力：

• 能快速识别题目类型（字符串处理、数组操作、动态规划等）
• 掌握华为机试的输入输出规范
• 学会用Python编写高效代码
• 了解常见错误和性能优化技巧

这些能力不仅能帮你通过华为机试，对找其他公司的工作也很有帮助。很多公司的编程面试题型都很相似，方法通用。

目录结构

项目结构保持简单直接，便于理解和扩展：

huawei_coding_test/
├── problems/
│   ├── __init__.py
│   ├── string_reverse.py      # 字符串反转
│   ├── array_sum.py           # 数组和计算
│   ├── binary_search.py       # 二分查找
│   ├── dp_change.py           # 动态规划-找零钱
│   └── tree_traversal.py      # 树遍历
├── tests/
│   ├── __init__.py
│   ├── test_string_reverse.py
│   ├── test_array_sum.py
│   └── test_all.py
├── utils/
│   ├── __init__.py
│   └── input_output.py        # 输入输出处理
├── main.py                    # 主程序入口
└── requirements.txt           # 依赖管理

每个题目一个文件，测试文件对应放置。utils目录放通用工具函数，比如输入输出处理。这种结构清晰，后期扩展也方便。

核心代码实现

题目1：字符串反转

题目描述：输入一个字符串，输出反转后的字符串。要求不能使用内置的reverse函数或切片。

解题思路：用双指针法，从两端向中间交换字符。时间复杂度O(n)，空间复杂度O(1)。

# problems/string_reverse.pydef reverse_string(s: str) -> str:"""反转字符串:param s: 输入字符串:return: 反转后的字符串"""if not s:return s# 转为列表，因为字符串不可变chars = list(s)left = 0right = len(chars) - 1while left < right:# 交换左右指针位置的字符chars[left], chars[right] = chars[right], chars[left]left += 1right -= 1return ''.join(chars)# 测试用例
if __name__ == "__main__":print(reverse_string("hello"))  # 输出: ollehprint(reverse_string("12345"))  # 输出: 54321print(reverse_string(""))       # 输出: 

关键点：字符串不可变，必须转列表操作。双指针比递归更直观，也不容易栈溢出。

题目2：数组和计算

题目描述：给定一个整数数组和目标和target，找出数组中两个数，使它们的和等于target。返回这两个数的索引。

解题思路：用哈希表记录已遍历的数，查找target - current是否在表中。时间复杂度O(n)。

# problems/array_sum.pydef two_sum(nums: list, target: int) -> list:"""两数之和:param nums: 整数数组:param target: 目标和:return: 两个数的索引列表"""# 哈希表：值 -> 索引num_map = {}for i, num in enumerate(nums):complement = target - num# 检查补数是否已在表中if complement in num_map:return [num_map[complement], i]# 记录当前数和索引num_map[num] = ireturn []  # 无解情况# 测试用例
if __name__ == "__main__":print(two_sum([2, 7, 11, 15], 9))  # 输出: [0, 1]print(two_sum([3, 2, 4], 6))        # 输出: [1, 2]print(two_sum([3, 3], 6))           # 输出: [0, 1]

避坑提示：注意数组可能有重复元素，哈希表要存索引而不是值。测试用例[3,3]就考察了这点。

题目3：二分查找

题目描述：在有序数组中查找目标值，返回索引。找不到返回-1。要求时间复杂度O(log n)。

解题思路：标准二分查找，注意边界条件。华为机试常考边界处理。

# problems/binary_search.pydef binary_search(nums: list, target: int) -> int:"""二分查找:param nums: 有序数组（升序）:param target: 目标值:return: 目标值索引，找不到返回-1"""left, right = 0, len(nums) - 1while left <= right:  # 注意是 <=，不是 <mid = left + (right - left) // 2  # 防止整数溢出mid_val = nums[mid]if mid_val == target:return midelif mid_val < target:left = mid + 1else:right = mid - 1return -1# 测试用例
if __name__ == "__main__":print(binary_search([1, 3, 5, 7, 9], 5))  # 输出: 2print(binary_search([1, 3, 5, 7, 9], 4))  # 输出: -1print(binary_search([], 1))                # 输出: -1print(binary_search([1], 1))               # 输出: 0

易错点：mid计算用left + (right - left) // 2而不是(left + right) // 2，后者在大数时可能溢出。虽然Python整数不会溢出，但这是好习惯。

题目4：动态规划-找零钱

题目描述：给定不同面额的硬币和总金额amount，计算凑成总金额所需的最少硬币个数。无解返回-1。

解题思路：经典动态规划问题。dp[i]表示凑成金额i所需的最少硬币数。

# problems/dp_change.pydef coin_change(coins: list, amount: int) -> int:"""最少硬币数:param coins: 硬币面额列表:param amount: 目标金额:return: 最少硬币数，无解返回-1"""if amount == 0:return 0# dp[i] 表示凑成金额 i 所需的最少硬币数dp = [float('inf')] * (amount + 1)dp[0] = 0  # 基础情况for i in range(1, amount + 1):for coin in coins:if coin <= i:# 状态转移：取当前硬币前的最优解+1dp[i] = min(dp[i], dp[i - coin] + 1)return -1 if dp[amount] == float('inf') else dp[amount]# 测试用例
if __name__ == "__main__":print(coin_change([1, 2, 5], 11))  # 输出: 3 (5+5+1)print(coin_change([2], 3))          # 输出: -1print(coin_change([1], 0))          # 输出: 0

核心思想：动态规划的关键是状态定义和转移方程。这里dp[i]依赖dp[i-coin]，所以从小到大计算。

题目5：树遍历

题目描述：实现二叉树的层序遍历，返回每层的节点值列表。

解题思路：用BFS，队列记录当前层节点。华为机试常考树操作。

# problems/tree_traversal.pyfrom collections import dequeclass TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = rightdef level_order(root: TreeNode) -> list:"""层序遍历:param root: 二叉树根节点:return: 每层节点值的列表"""if not root:return []result = []queue = deque([root])while queue:level_size = len(queue)level_values = []for _ in range(level_size):node = queue.popleft()level_values.append(node.val)if node.left:queue.append(node.left)if node.right:queue.append(node.right)result.append(level_values)return result# 测试用例
if __name__ == "__main__":#       3#      / \#     9   20#        /  \#       15   7root = TreeNode(3)root.left = TreeNode(9)root.right = TreeNode(20)root.right.left = TreeNode(15)root.right.right = TreeNode(7)print(level_order(root))  # 输出: [[3], [9, 20], [15, 7]]

关键细节：每次循环前记录队列长度，这就是当前层的节点数。处理完这一层再处理下一层。

运行与测试

环境配置

# 创建虚拟环境
python -m venv venv
source venv/bin/activate  # Windows用 venv\Scripts\activate# 安装依赖
pip install -r requirements.txt

requirements.txt内容：

pytest>=7.0.0

运行测试

# tests/test_all.pyimport pytest
from problems.string_reverse import reverse_string
from problems.array_sum import two_sum
from problems.binary_search import binary_search
from problems.dp_change import coin_changedef test_string_reverse():assert reverse_string("hello") == "olleh"assert reverse_string("") == ""def test_two_sum():assert two_sum([2, 7, 11, 15], 9) == [0, 1]assert two_sum([3, 3], 6) == [0, 1]def test_binary_search():assert binary_search([1, 3, 5, 7, 9], 5) == 2assert binary_search([1, 3, 5, 7, 9], 4) == -1def test_coin_change():assert coin_change([1, 2, 5], 11) == 3assert coin_change([2], 3) == -1

运行测试：

pytest tests/ -v

预期输出：

========================= test session starts ==========================
collected 4 itemstests/test_all.py::test_string_reverse PASSED       [ 25%]
tests/test_all.py::test_two_sum PASSED              [ 50%]
tests/test_all.py::test_binary_search PASSED        [ 75%]
tests/test_all.py::test_coin_change PASSED          [100%]========================= 4 passed in 0.02s ===========================

输入输出规范

华为机试有严格的输入输出要求。参考RFC 8259规范，JSON格式是常用数据传输格式。虽然机试不一定用JSON，但理解结构化数据有助于处理复杂输入。

# utils/input_output.pydef read_input():"""读取标准输入华为机试通常是：第一行测试用例数量，之后每行一个用例"""import sysinput_lines = sys.stdin.read().splitlines()if not input_lines:return []test_cases = []for line in input_lines:line = line.strip()if line:test_cases.append(line)return test_casesdef write_output(result):"""写入标准输出每行一个结果"""print(result)

重要提醒：华为机试的输入输出格式每年可能变化，务必查看当年最新要求。上面代码只是示例，实际以官网说明为准。

优化扩展

性能优化技巧

1. 避免重复计算：动态规划的核心，记住之前计算的结果
2. 空间换时间：哈希表、缓存等数据结构
3. 提前终止：找到答案立即返回，不要继续遍历

常见错误排查

错误类型	表现	解决方案
索引越界	IndexError	检查边界条件，left <= right
逻辑错误	输出不对	打印中间变量，单步调试
超时	TLE	优化算法复杂度，O(n²)改O(n)
内存溢出	MLE	避免递归过深，用迭代

进阶练习建议

1. 限时训练：每题15-20分钟，模拟考试压力
2. 变体练习：同一题型的不同变体，比如两数之和的三数之和
3. 代码审查：写完后自己检查边界情况、异常处理
4. 跨语言实现：用Java或C++重写，加深理解

与其他岗位证书的区别

华为机试不是证书考试，是招聘流程的一部分。不像软考或PMP那种标准化证书，它考察的是实际编码能力。准备思路完全不同：

• 软考：重理论，选择题为主，需要背知识点
• 华为机试：重实践，编程题为主，需要写代码
• PMP：重管理，案例题为主，需要理解流程

所以别用准备证书的方法准备机试。刷题、写代码、测试验证，这才是正道。

小结

通过这5道题，你掌握了华为机试的典型题型和解题方法。记住几个关键点：

1. 先理解题意：不要急着写代码，花2-3分钟分析输入输出、边界情况
2. 选择合适算法：字符串用双指针，查找用哈希或二分，最优解用动态规划
3. 注意边界：空输入、单元素、最大值最小值都要测试
4. 代码要规范：变量命名清晰，关键步骤加注释

最后问一个问题：这个知识点你面试被问过吗？留言说说你遇到的具体题目，或者你的解题思路。大家一起交流，互相学习。