2026年IT企业技术大牛面试题目剖析.docxVIP

第PAGE页共NUMPAGES页

2026年IT企业技术大牛面试题目剖析

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

题目1（Java）：

实现一个LRU（LeastRecentlyUsed）缓存，支持get和put操作。缓存容量为固定值，当缓存满时，最近最少使用的元素将被移除。请用Java实现该缓存，并说明时间复杂度和空间复杂度。

答案与解析：

java

importjava.util.HashMap;

importjava.util.Map;

classLRUCacheK,V{

privatefinalintcapacity;

privatefinalMapK,NodeK,Vmap;

privatefinalNodeK,Vhead,tail;

staticclassNodeK,V{

Kkey;

Vvalue;

NodeK,Vprev;

NodeK,Vnext;

Node(Kkey,Vvalue){

this.key=key;

this.value=value;

}

}

publicLRUCache(intcapacity){

this.capacity=capacity;

map=newHashMap();

head=newNode(null,null);

tail=newNode(null,null);

head.next=tail;

tail.prev=head;

}

publicVget(Kkey){

NodeK,Vnode=map.get(key);

if(node==null)returnnull;

moveToHead(node);

returnnode.value;

}

publicvoidput(Kkey,Vvalue){

NodeK,Vnode=map.get(key);

if(node!=null){

node.value=value;

moveToHead(node);

}else{

NodeK,VnewNode=newNode(key,value);

map.put(key,newNode);

addToHead(newNode);

if(map.size()capacity){

NodeK,VtailPrev=removeTail();

map.remove(tailPrev.key);

}

}

}

privatevoidmoveToHead(NodeK,Vnode){

removeNode(node);

addToHead(node);

}

privatevoidaddToHead(NodeK,Vnode){

node.prev=head;

node.next=head.next;

head.next.prev=node;

head.next=node;

}

privateNodeK,VremoveTail(){

NodeK,Vres=tail.prev;

removeNode(res);

returnres;

}

privatevoidremoveNode(NodeK,Vnode){

node.prev.next=node.next;

node.next.prev=node.prev;

}

}

解析：

1.数据结构选择：使用双向链表+哈希表实现。双向链表维护最近使用顺序，哈希表实现O(1)时间复杂度的get和put操作。

2.时间复杂度：get和put均为O(1)。

3.空间复杂度：O(capacity)，存储最多capacity个元素。

题目2（Python）：

给定一个包含重复元素的数组，请找出所有不重复的三元组，使得三元组的和等于给定值target。例如，输入`nums=[-1,0,1,2,-1,-4]`，`target=0`，输出`[[-1,0,1],[-1,-1,2]]`。

答案与解析：

python

defthreeSum(nums,target):

nums.sort()

n=len(nums)

res=[]

foriinrange(n):

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

continue

left,right=i+1,n-1

whileleftright:

total=nums[i]+nums[left]+nums[right]

iftotal==ta