2026年微软研发工程师面试题目.docxVIP

第PAGE页共NUMPAGES页

2026年微软研发工程师面试题目

一、编程算法题（共5题，每题10分，总分50分）

1.题目：

给定一个非空整数数组，返回所有连续子数组的和。要求不使用递归，时间复杂度O(n)。

示例：

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

输出：`[6,6,6]`（解释：子数组分别为[1],[2],[3]的和）

答案：

python

defsubarray_sums(nums):

result=[]

foriinrange(len(nums)):

total=0

forjinrange(i,len(nums)):

total+=nums[j]

result.append(total)

returnresult

解析：

使用双层循环遍历所有子数组，外层循环确定子数组的起始位置，内层循环计算从起始位置到末尾的连续和。时间复杂度为O(n2)，但题目要求O(n)可优化为前缀和。

优化答案：

python

defsubarray_sums_optimized(nums):

result=[]

prefix_sum=[0](len(nums)+1)

foriinrange(len(nums)):

prefix_sum[i+1]=prefix_sum[i]+nums[i]

foriinrange(len(nums)):

forjinrange(i+1,len(nums)+1):

result.append(prefix_sum[j]-prefix_sum[i])

returnresult

解析：

通过前缀和数组`prefix_sum`，子数组`[i,j]`的和可以表示为`prefix_sum[j]-prefix_sum[i]`，时间复杂度降为O(n2)，但实际可用优化。

进一步优化（O(n)）：

python

defsubarray_sums_final(nums):

result=[]

total=0

foriinrange(len(nums)):

total+=nums[i]

result.append(total)

forjinrange(i+1,len(nums)):

total+=nums[j]-nums[i]

result.append(total)

returnresult

解析：

外层循环计算以每个位置为起点的子数组和，内层循环逐步扩展子数组范围，避免重复计算。

2.题目：

实现一个LRU（最近最少使用）缓存，支持`get`和`put`操作。要求用哈希表+双向链表实现，时间复杂度O(1)。

示例：

python

LRUCache=LRUCache(2)

LRUCache.put(1,1)

LRUCache.put(2,2)

LRUCache.get(1)#返回1

LRUCache.put(3,3)#去除键2

LRUCache.get(2)#返回-1(未找到)

答案：

python

classDLinkedNode:

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,self.tail=DLinkedNode(),DLinkedNode()

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_head(node)

returnnode.value

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

ifkeyinself.cache:

node=self.cache[key]

node.value=value

self._move_to_head(node)

else:

node=DLinkedNode(key,value)

self.cache[key]=node

self._add_node(node)

iflen(s