思路
哈希表 + 双向链表。在面试中，面试官一般会期望读者能够自己实现一个简单的双向链表，而不是使用语言自带的、封装好的数据结构。
方法一：哈希表 + C++自带的双向链表 list
1 struct Node {
2 int key;
3 int value;
4 Node(){}
5 Node(int _key,int _value): key(_key), value(_value){}
6 };
7
8 class LRUCache {
9 private:
10 int capacity;
11 list<Node*> cache;
12 unordered_map<int, list<Node*>::iterator> mp;
13 public:
14 LRUCache(int capacity) {
15 this->capacity = capacity;
16 }
17
18 int get(int key) {
19 if(mp.find(key) != mp.end()) {
20 //将其更新到队头
21 Node* node = *(mp[key]);
22 cache.erase(mp[key]);
23 cache.push_front(node);
24 mp[key] = cache.begin();
25
26 //返回对应的值
27 return node->value;
28 } else {
29 return -1;
30 }
31 }
32
33 void put(int key, int value) {
34 if(mp.find(key) != mp.end()) {
35 Node* node = *(mp[key]);
36 cache.erase(mp[key]);
37 node->value = value;
38 cache.push_front(node);
39 mp[key] = cache.begin();
40 } else {
41 Node* node = new Node(key, value);
42 cache.push_front(node);
43 mp[key] = cache.begin();
44 if(cache.size() > capacity) {
45 mp.erase(cache.back()->key);
46 cache.pop_back();
47 }
48 }
49 }
50 };
51
52 /**
53 * Your LRUCache object will be instantiated and called as such:
54 * LRUCache* obj = new LRUCache(capacity);
55 * int param_1 = obj->get(key);
56 * obj->put(key,value);
57 */复杂度分析
时间复杂度：get和put都是O(1)。
方法二：哈希表 + 自己实现的简单双向链表
1 struct DLinkedNode {
2 int key, value;
3 DLinkedNode* prev;
4 DLinkedNode* next;
5 DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {}
6 DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {}
7 };
8
9 class LRUCache {
10 private:
11 unordered_map<int, DLinkedNode*> cache;
12 DLinkedNode* head;
13 DLinkedNode* tail;
14 int size;
15 int capacity;
16
17 public:
18 LRUCache(int _capacity): capacity(_capacity), size(0) {
19 // 使用伪头部和伪尾部节点
20 head = new DLinkedNode();
21 tail = new DLinkedNode();
22 head->next = tail;
23 tail->prev = head;
24 }
25
26 int get(int key) {
27 if (!cache.count(key)) {
28 return -1;
29 }
30 // 如果 key 存在，先通过哈希表定位，再移到头部
31 DLinkedNode* node = cache[key];
32 moveToHead(node);
33 return node->value;
34 }
35
36 void put(int key, int value) {
37 if (!cache.count(key)) {
38 // 如果 key 不存在，创建一个新的节点
39 DLinkedNode* node = new DLinkedNode(key, value);
40 // 添加进哈希表
41 cache[key] = node;
42 // 添加至双向链表的头部
43 addToHead(node);
44 ++size;
45 if (size > capacity) {
46 // 如果超出容量，删除双向链表的尾部节点
47 DLinkedNode* removed = removeTail();
48 // 删除哈希表中对应的项
49 cache.erase(removed->key);
50 // 防止内存泄漏
51 delete removed;
52 --size;
53 }
54 }
55 else {
56 // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
57 DLinkedNode* node = cache[key];
58 node->value = value;
59 moveToHead(node);
60 }
61 }
62
63 void addToHead(DLinkedNode* node) {
64 node->prev = head;
65 node->next = head->next;
66 head->next->prev = node;
67 head->next = node;
68 }
69
70 void removeNode(DLinkedNode* node) {
71 node->prev->next = node->next;
72 node->next->prev = node->prev;
73 }
74
75 void moveToHead(DLinkedNode* node) {
76 removeNode(node);
77 addToHead(node);
78 }
79
80 DLinkedNode* removeTail() {
81 DLinkedNode* node = tail->prev;
82 removeNode(node);
83 return node;
84 }
85 };
复杂度分析
时间复杂度：对于 put 和 get 都是 O(1)。
空间复杂度：O(capacity)，因为哈希表和双向链表最多存储 capacity + 1个元素。
