力扣算法题—460LFU缓存

【题目描述】

设计并实现最不经常使用（LFU）缓存的数据结构。它应该支持以下操作：get 和 put。

get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。

put(key, value) - 如果键不存在，请设置或插入值。当缓存达到其容量时，它应该在插入新项目之前，使最不经常使用的项目无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，最近最少使用的键将被去除。

进阶：

你是否可以在 O(1) 时间复杂度内执行两项操作？

示例：

LFUCache cache = new LFUCache( 2 /*capacity (缓存容量) */ );

cache.put(1, 1);

cache.put(2, 2);

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

cache.put(3, 3); // 去除 key 2

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

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

cache.put(4, 4); // 去除 key 1

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

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

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

【解题思路】

解题思路见我博客：左神算法进阶班6_1LFU缓存实现

【代码实现】

　　

 #pragma once
 #include <iostream>
 #include <map>

 using namespace std;

 class LFUCache {
 public:
     LFUCache(int capacity) {
         this->capacity = capacity;
     }

     int get(int key) {
         if (dataMap.find(key) == dataMap.end())//数据不存在
             return -;
         Node* p = dataMap[key];//找到数据节点
         NodeList* h = headMap[p->num];
         updataNode(p, h);

         return p->val;
     }

     void put(int key, int value) {
         if (capacity == )
             return;
         if (dataMap.find(key) != dataMap.end())//已经存在
         {
             Node* p = dataMap[key];//找到数据节点
             NodeList* h = headMap[p->num];//找到头链表节点
             p->val = value;

             updataNode(p, h);//更新数据的使用次数
         }
         else//如果不存在，则新建
         {
             if (dataMap.size() >= this->capacity)//容量不足，需要删除数据
                 deleteData();

             Node* p = new Node(key, value, );//使用用一次
             dataMap[key] = p;//记录

             //将新建节点插入使用1次的子链表中
             if (headMap.find() == headMap.end())//当使用1次的子链表不存在
                 createNode(p, headList);
             else
                 moveNode(p, headMap[]);//插入在使用次数在1的子链表中
         }
     }

 private:
     struct Node//子链表
     {
         int key;
         int val;
         int num;
         Node* next;
         Node* pre;
         Node(int a, int b, int n) :key(a), val(b), num(n), next(nullptr), pre(nullptr) {}
     };

     struct NodeList//主链表
     {
         int num;
         Node* head;//子链表的头节点
         Node* tail;//子链表的尾结点
         NodeList* next;
         NodeList* pre;
         NodeList(int a) :num(a), next(nullptr), pre(nullptr)
         {
             head = new Node(, , a);//新建一个子链表的头结点
             tail = head;
         }
     };

 private:
     void getNode(Node*& p, NodeList*& h)//将节点从子链表中取出
     {
         p->pre->next = p->next;
         if (p->next == nullptr)
             h->tail = p->pre;
         else
             p->next->pre = p->pre;
     }
     void moveNode(Node*& p, NodeList*& q)//将节点向后移动
     {
         p->next = q->tail->next;
         q->tail->next = p;
         p->pre = q->tail;
         q->tail = p;
     }
     void deleteNode(int num, NodeList*& h)//删除子链表
     {
         headMap.erase(num);//从map中删除
         h->pre->next = h->next;
         if (h->next != nullptr)
             h->next->pre = h->pre;
         delete h;
         h = nullptr;
     }
     void createNode(Node*p, NodeList*& h)//新建子链表,并插入在主链中
     {
         NodeList* q = new NodeList(p->num);//新建一个子链表
         headMap[p->num] = q;//保存对应的地址

         moveNode(p, q);////将节点放入子链表中        

         //将新子链插入主链表中
         q->next = h->next;
         if (h->next != nullptr)
             h->next->pre = q;
         h->next = q;
         q->pre = h;
     }
     void updataNode(Node*& p, NodeList*& h)//更新函数的使用次数
     {
         int num = p->num;
         p->num++;//使用次数+1

         //将p从子链表中取出
         getNode(p, h);

         //将该数据向后面移动
         if (headMap.find(p->num) == headMap.end())//不存在num+1的节点,那么新建
             createNode(p, h);
         else
             moveNode(p, headMap[p->num]);////将节点放入子链表中    

         //如果该子链表为空，将该子链表删除,并从map中删除
         if (h->head == h->tail)
             deleteNode(num, h);
     }
     void deleteData()//容量不足需要删除
     {
         NodeList* p = headList->next;
         Node* q = p->head->next;//删除子链表排在最前面的数据
         if (q == p->tail)//要删除的数据就是最后一个数据，则删除该节点和子链表
             deleteNode(q->num, p);
         else
         {
             p->head->next = q->next;
             q->next->pre = p->head;
         }
         dataMap.erase(q->key);//删除记录
         delete q;//删除
         q = nullptr;
     }

 private:
     int capacity;
     NodeList* headList = new NodeList();//主链表的头结点
     map<int, Node*>dataMap;//key  <——>  真实数据节点地址
     map<int, NodeList*>headMap;//次数 <——>  链表头节点地址
 };

 /**
  * Your LFUCache object will be instantiated and called as such:
  * LFUCache* obj = new LFUCache(capacity);
  * int param_1 = obj->get(key);
  * obj->put(key,value);
  */

 void Test()
 {
     LFUCache* f = new LFUCache();
     f->put(, );
     f->put(, );
     f->put(, );
     f->put(, );
     cout << f->get() << endl;
     cout << f->get() << endl;
     cout << f->get() << endl;
     cout << f->get() << endl;
     f->put(, );
     cout << f->get() << endl;
     cout << f->get() << endl;
     cout << f->get() << endl;
     cout << f->get() << endl;
     cout << f->get() << endl;

 }