2026年算法工程师系统面试题及答案.docxVIP

第PAGE页共NUMPAGES页

2026年算法工程师系统面试题及答案

一、编程题（共3题，每题20分，总分60分）

1.题目（20分）：

给定一个包含重复元素的数组，返回所有可能的子集（无重复元素）。例如，输入`[1,2,2]`，输出`[[],[1],[1,2],[1,2,2],[2],[2,2]]`。

要求：

-不能使用递归，只能使用迭代方法（如回溯法）实现。

-时间复杂度尽可能低。

答案与解析：

python

defsubsetsWithDup(nums):

res=[]

nums.sort()#先排序，方便去重

subset=[]

defbacktrack(start):

res.append(subset.copy())

foriinrange(start,len(nums)):

ifistartandnums[i]==nums[i-1]:

continue#去重

subset.append(nums[i])

backtrack(i+1)

subset.pop()

backtrack(0)

returnres

测试用例

print(subsetsWithDup([1,2,2]))

解析：

1.排序：先对数组排序，这样重复元素会相邻，方便跳过重复的子集。

2.迭代回溯：使用`backtrack`函数，从`start`位置开始枚举每个元素，如果当前元素与上一个元素相同且不在同一层，则跳过（去重）。

3.时间复杂度：O(2^n)，因为每个元素有选择或不选择的两种情况，但去重后实际复杂度会降低。

2.题目（20分）：

设计一个LRU（最近最少使用）缓存，支持`get`和`put`操作。LRU缓存最多容纳`capacity`个元素，超出时需要删除最久未使用的元素。

要求：

-使用哈希表+双向链表实现，哈希表用于快速查找，链表用于维护访问顺序。

-`get(key)`返回键对应的值，如果不存在返回`-1`。

-`put(key,value)`插入或更新键值对，如果超出容量则删除最久未使用的元素。

答案与解析：

python

classListNode:

def__init__(self,key=0,value=0):

self.key=key

self.value=value

self.prev=None

self.next=None

classLRUCache:

def__init__(self,capacity:int):

self.capacity=capacity

self.cache={}

self.head=ListNode(0,0)

self.tail=ListNode(0,0)

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.