LeetCode 每日一题 146. LRU缓存机制

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

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

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lru-cache
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

双向链表来存储数据，unordered_map 作 hash 用于存储是否存在对应 key。
LRU 的最近使用靠将节点在双向链表中移至首部实现，末尾自然淘汰。

class LRUCache {
 private:
  struct Node {
    struct Node*prev, *next;
    int key, val;
    Node(): prev(nullptr), next(nullptr), key(0), val(0) {};
    Node(int _key, int _val): key(_key), val(_val), prev(nullptr), next(nullptr) {};
  };

  unordered_map<int, Node*>cache;
  Node *head, *tail;
  int size, capacity;

  inline void move_to_head(Node *targ) {
    remove_node(targ);
    insert_to_head(targ);
  }

  inline void insert_to_head(Node *targ) {
    targ->next = head->next;
    targ->prev = head;
    head->next->prev = targ;
    head->next = targ;
  }

  inline Node* remove_node(Node*targ) {
    if(targ == head || targ == tail)
      return nullptr;
    targ->prev->next = targ->next;
    targ->next->prev = targ->prev;
    targ->prev = targ->next = nullptr;
    return targ;
  }

  inline Node*remove_the_tail() {
    Node *targ = tail->prev;
    if(targ == head)
      return nullptr;
    remove_node(targ);
    return targ;
  }

 public:

  LRUCache(int _capacity) {
    head = new Node();
    tail = new Node();
    head->next = tail, tail->prev = head;
    size = 0;
    capacity = _capacity;
  }

  int get(int key) {
    if(cache.count(key) == 0)
      return -1;
    Node *tar = cache[key];
    move_to_head(tar);
    return tar->val;
  }

  void put(int key, int value) {
    Node *targ;
    if(cache.count(key) == 0) {
      targ = new Node(key, value);
      cache[key] = targ;
      insert_to_head(targ);
      size++;
      if(size > capacity) {
        Node *removed_elem = remove_the_tail();
        cache.erase(removed_elem->key);
        size--;
      }
    } else {
      targ = cache[key];
      targ->val = value;
      move_to_head(targ);
    }
  }
};

/**
 * 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);
 */