为了防止内存泄漏，你需要在适当的地方添加 delete 操作符来释放通过 new 分配的内存。在你的代码中，可以在 LRUCache 的析构函数中遍历链表并删除所有节点。下面是修改后的代码：
#include <unordered_map>
using namespace std;
struct Node {
int key;
int value;
Node* prev;
Node* next;
Node() : key(0), value(0), prev(nullptr), next(nullptr) {}
Node(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {}
};
class LRUCache {
public:
unordered_map<int, Node*> uset;
int size, capacity;
Node* head;
Node* tail;
LRUCache(int _capacity) : capacity(_capacity), size(0) {
head = new Node();
tail = new Node();
head->next = tail;
tail->prev = head;
}
~LRUCache() {
// 清理所有分配的节点以避免内存泄漏
Node* current = head;
while (current != nullptr) {
Node* nextNode = current->next; // 保存下一个节点
delete current; // 删除当前节点
current = nextNode; // 移动到下一个节点
}
}
void removenode(Node* node) {
node->prev->next = node->next;
node->next->prev = node->prev;
}
void addnodetohead(Node* node) {
node->next = head->next;
head->next->prev = node;
head->next = node;
node->prev = head;
}
int get(int key) {
if (!uset.count(key)) {
return -1;
}
Node* node = uset[key];
removenode(node);
addnodetohead(node);
return node->value;
}
void put(int key, int value) {
if (uset.count(key)) {
Node* node = uset[key];
node->value = value;
removenode(node);
addnodetohead(node);
} else {
if (size == capacity) {
Node* tempnode = tail->prev;
uset.erase(tempnode->key);
removenode(tempnode);
delete tempnode; // 释放内存
size--;
}
Node* newnode = new Node(key, value);
addnodetohead(newnode);
uset[key] = newnode;
size++;
}
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache* obj = new LRUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/
修改点：
- Destructor (
~LRUCache)：在析构函数中遍历链表，删除每个节点。 - 在
put方法中，当从缓存中移除最旧的节点时，添加了对该节点的delete调用，以释放其占用的内存。
这样，在不再使用 LRUCache 对象时，它所占用的所有动态分配的内存都将被正确释放。
内容由零声教学AI助手提供，问题来源于学员提问
