华为技术部面试指南及答案详解.docxVIP

第PAGE页共NUMPAGES页

2026年华为技术部面试指南及答案详解

一、编程基础与算法（5题，每题8分，共40分）

1.题目：

给定一个无重复元素的整数数组，返回所有可能的子集。子集的元素顺序不重要。

示例输入：`[1,2,3]`

示例输出：`[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]`

答案：

python

defsubsets(nums):

result=[]

subset=[]

defbacktrack(index):

result.append(subset.copy())

foriinrange(index,len(nums)):

subset.append(nums[i])

backtrack(i+1)

subset.pop()

backtrack(0)

returnresult

解析：

使用回溯算法，通过递归构建所有可能的子集。每次选择当前元素加入子集，然后继续递归；不选择时直接递归。关键在于`index`参数，确保每个元素只被选择一次且顺序固定。

2.题目：

实现一个LRU（LeastRecentlyUsed）缓存，支持`get`和`put`操作。缓存容量为`capacity`。

示例：

-`LRU_cache=LRUCache(2)`

-`LRU_cache.put(1,1)`→缓存是`{1=1}`

-`LRU_cache.put(2,2)`→缓存是`{1=1,2=2}`

-`LRU_cache.get(1)`→返回`1`，缓存是`{2=2,1=1}`（1被访问，最近使用）

-`LRU_cache.put(3,3)`→缓存容量满，删除最久未使用元素`2`，缓存是`{1=1,3=3}`

-`LRU_cache.get(2)`→返回`-1`，因为`2`不在缓存中

答案：

python

classListNode:

def__init__(self,key=0,value=0,prev=None,next=None):

self.key=key

self.value=value

self.prev=prev

self.next=next

classLRUCache:

def__init__(self,capacity:int):

self.capacity=capacity

self.cache={}

self.head=ListNode()

self.tail=ListNode()

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=node.prev

next_node=node.next

prev_node.next=next_node

next_node.prev=prev_node

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)

returnres

defget(self,key:int)-int:

node=self.cache.get(key,None)

ifnotnode:

return-1

self._move_to_head(node)

returnnode.value

defput(self,key:int,value:int)-None:

node=self.cache.get(key)

ifnode:

node.value=value

self._move_to_head(node)

else:

newNode=ListNode(key,value)

self.cache[key]=newNode

self._add_node(newNode)

iflen(self.cache)self.capacity:

tail=self._pop_tail()

dels