2026年软件工程师面试题与答案解析.docxVIP

第PAGE页共NUMPAGES页

2026年软件工程师面试题与答案解析

一、编程题（共5题，每题20分，总分100分）

题目1（Java）：实现一个LRU缓存机制

要求：

-使用Java语言实现LRU（LeastRecentlyUsed）缓存，支持容量限制。

-提供`get(key)`和`put(key,value)`方法。

-使用双向链表和哈希表结合的方式实现，时间复杂度为O(1)。

示例：

java

LRUCachecache=newLRUCache(2);

cache.put(1,1);//缓存是{1=1}

cache.put(2,2);//缓存是{1=1,2=2}

cache.get(1);//返回1

cache.put(3,3);//去除键2，缓存是{1=1,3=3}

cache.get(2);//返回-1(未找到)

cache.put(4,4);//去除键1，缓存是{4=4,3=3}

cache.get(1);//返回-1(未找到)

cache.get(3);//返回3

cache.get(4);//返回4

答案：

java

importjava.util.HashMap;

importjava.util.Map;

classLRUCache{

privateintcapacity;

privateMapInteger,Nodecache;

privateNodehead,tail;

classNode{

intkey;

intvalue;

Nodeprev;

Nodenext;

Node(intkey,intvalue){

this.key=key;

this.value=value;

}

}

publicLRUCache(intcapacity){

this.capacity=capacity;

cache=newHashMap();

head=newNode(0,0);

tail=newNode(0,0);

head.next=tail;

tail.prev=head;

}

publicintget(intkey){

if(cache.containsKey(key)){

Nodenode=cache.get(key);

moveToHead(node);

returnnode.value;

}

return-1;

}

publicvoidput(intkey,intvalue){

if(cache.containsKey(key)){

Nodenode=cache.get(key);

node.value=value;

moveToHead(node);

}else{

if(cache.size()==capacity){

Nodelru=tail.prev;

cache.remove(lru.key);

removeNode(lru);

}

NodenewNode=newNode(key,value);

cache.put(key,newNode);

addToHead(newNode);

}

}

privatevoidaddToHead(Nodenode){

node.prev=head;

node.next=head.next;

head.next.prev=node;

head.next=node;

}

privatevoidremoveNode(Nodenode){

node.prev.next=node.next;

node.next.prev=node.prev;

}

privatevoidmoveToHead(Nodenode){

removeNode(node);

addToHead(node);

}

}

解析：

-使用双向链表维护访问顺序，头节点为最近访问，尾节点为最久未访问。

-哈希表用于快速查找节点，避免遍历链表。

-`get`操作将节点移动到头节点，`put`操作先检查是否已存在，若存在则更新并移动到头节点；若不存在且容量已满，则删除尾节点并插入新节点。

题目2（Python）：实现一个二叉树的最大深度计算

要求：

-编写Python函数`maxDepth(root)`，计算二叉树的最大深度（根节点到最远叶节点的路径长度）。

-使用递归方式实现。

示例：

python

定义二叉树节点

classTreeNode:

de