ZBLOG

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: ...

为了防止内存泄漏,你需要在适当的地方添加 delete 操作符来释放通过 new 分配的内存。在你的代码中,可以在 LRUCache 的析构函数中遍历链表并删除所有节点。下面是修改后的代码:

  1. #include <unordered_map>
  2. using namespace std;
  3. struct Node {
  4. int key;
  5. int value;
  6. Node* prev;
  7. Node* next;
  8. Node() : key(0), value(0), prev(nullptr), next(nullptr) {}
  9. Node(int _key, int _value) : key(_key), value(_value), prev(nullptr), next(nullptr) {}
  10. };
  11. class LRUCache {
  12. public:
  13. unordered_map<int, Node*> uset;
  14. int size, capacity;
  15. Node* head;
  16. Node* tail;
  17. LRUCache(int _capacity) : capacity(_capacity), size(0) {
  18. head = new Node();
  19. tail = new Node();
  20. head->next = tail;
  21. tail->prev = head;
  22. }
  23. ~LRUCache() {
  24. // 清理所有分配的节点以避免内存泄漏
  25. Node* current = head;
  26. while (current != nullptr) {
  27. Node* nextNode = current->next; // 保存下一个节点
  28. delete current; // 删除当前节点
  29. current = nextNode; // 移动到下一个节点
  30. }
  31. }
  32. void removenode(Node* node) {
  33. node->prev->next = node->next;
  34. node->next->prev = node->prev;
  35. }
  36. void addnodetohead(Node* node) {
  37. node->next = head->next;
  38. head->next->prev = node;
  39. head->next = node;
  40. node->prev = head;
  41. }
  42. int get(int key) {
  43. if (!uset.count(key)) {
  44. return -1;
  45. }
  46. Node* node = uset[key];
  47. removenode(node);
  48. addnodetohead(node);
  49. return node->value;
  50. }
  51. void put(int key, int value) {
  52. if (uset.count(key)) {
  53. Node* node = uset[key];
  54. node->value = value;
  55. removenode(node);
  56. addnodetohead(node);
  57. } else {
  58. if (size == capacity) {
  59. Node* tempnode = tail->prev;
  60. uset.erase(tempnode->key);
  61. removenode(tempnode);
  62. delete tempnode; // 释放内存
  63. size--;
  64. }
  65. Node* newnode = new Node(key, value);
  66. addnodetohead(newnode);
  67. uset[key] = newnode;
  68. size++;
  69. }
  70. }
  71. };
  72. /**
  73. * Your LRUCache object will be instantiated and called as such:
  74. * LRUCache* obj = new LRUCache(capacity);
  75. * int param_1 = obj->get(key);
  76. * obj->put(key,value);
  77. */

修改点:

  1. Destructor (~LRUCache):在析构函数中遍历链表,删除每个节点。
  2. put 方法中,当从缓存中移除最旧的节点时,添加了对该节点的 delete 调用,以释放其占用的内存。

这样,在不再使用 LRUCache 对象时,它所占用的所有动态分配的内存都将被正确释放。


内容由零声教学AI助手提供,问题来源于学员提问

本站部分文章来源于网络,版权归原作者所有,如有侵权请联系站长删除。
转载请注明出处:https://golang.0voice.com/?id=22620

分享:
扫描分享到社交APP
上一篇
下一篇
发表列表
游客 游客
此处应有掌声~
评论列表

还没有评论,快来说点什么吧~

联系我们

在线咨询: 点击这里给我发消息

微信号:3007537140

上班时间: 10:30-22:30

关注我们
x

注册

已经有帐号?