2026年百度算法工程师面试要点与答案参考.docxVIP

第PAGE页共NUMPAGES页

2026年百度算法工程师面试要点与答案参考

一、编程基础与数据结构（5题，每题8分，共40分）

1.题目（8分）：

实现一个函数，输入一个无重复元素的数组，返回所有可能的子集（包括空集）。要求使用递归方法，并输出所有子集的列表。

答案与解析：

python

defsubsets(nums):

result=[]

defbacktrack(start,path):

result.append(path)

foriinrange(start,len(nums)):

backtrack(i+1,path+[nums[i]])

backtrack(0,[])

returnresult

示例输入

print(subsets([1,2,3]))

解析：

-递归的核心是“选择与不选择”。每次从数组中选取一个元素，递归地处理剩余部分，同时保留当前路径。

-时间复杂度：O(2^n)，因为每个元素都有两种选择（选或不选）。

-空间复杂度：O(n)，递归栈的深度为n。

2.题目（8分）：

给定一个链表，判断其是否为回文链表。要求不使用额外空间，时间复杂度尽可能低。

答案与解析：

python

classListNode:

def__init__(self,val=0,next=None):

self.val=val

self.next=next

defisPalindrome(head):

ifnotheadornothead.next:

returnTrue

找到链表中间节点

slow=fast=head

whilefastandfast.next:

slow=slow.next

fast=fast.next.next

反转后半部分链表

prev=None

whileslow:

temp=slow.next

slow.next=prev

prev=slow

slow=temp

对比前后半部分

left,right=head,prev

whileright:#只需比较到后半部分结束

ifleft.val!=right.val:

returnFalse

left=left.next

right=right.next

returnTrue

解析：

-快慢指针找到中点，反转后半部分，然后对比前后部分是否一致。

-时间复杂度：O(n)，空间复杂度：O(1)。

3.题目（8分）：

设计一个LRU（LeastRecentlyUsed）缓存，支持get和put操作。要求使用哈希表+双向链表实现。

答案与解析：

python

classLRUCache:

classNode:

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

self.key=key

self.value=value

self.prev=None

self.next=None

def__init__(self,capacity:int):

self.capacity=capacity

self.cache={}

self.head,self.tail=self.Node(),self.Node()

self.head.next=self.tail

self.tail.prev=self.head

defget(self,key:int)-int:

ifkeynotinself.cache:

return-1

node=self.cache[key]

self._move_to_front(node)

returnnode.value

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

ifkeyinself.cache:

node=self.cache[key]

node.value=value

self._move_to_front(node)

else:

node=self.Node(key,value)

self.cache[key]=node

self._add_to_front(node)

iflen(self.cache)self.capacity:

self._remove_lru_node()

def_move_to_front(self,node):

self._remove_node(node)

self._add_to_front(node)

def_add_to_front(self,node):