力扣热题100 - 遇到的阿里面试题之一 - 链表：LRU缓存

题目描述：

题号：146

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存

• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。

• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

解题思路：

思路一：哈希表 + 双向链表

哈希表是一种查询时具有 O(1) 时间复杂度的数据结构，而 LRU 缓存常常使用双向链表来实现。

因此，我们可以使用双向链表保存元素以便于方便的获知哪个元素该被淘汰了，未被淘汰的元素则保存在哈希表中。

时间复杂度：O(1)

空间复杂度：O(N)

C++

// C++
struct DLinkedNode {
    int key, value;
    DLinkedNode* prev;
    DLinkedNode* next;
    DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {}
    DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr), next(nullptr) {}
};

class LRUCache {
private:
    unordered_map cache;
    DLinkedNode* head;
    DLinkedNode* tail;
    int size;
    int capacity;

public:
    LRUCache(int _capacity) : capacity(_capacity), size(0) {
        //伪头部
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head->next = tail;
        tail->prev = head;
    }
    
    int get(int key) {
        if (cache.count(key) == 0) {
            return -1;
        }
        //key存在,先定位再移动到头部
        DLinkedNode* node = cache[key];
        moveToHead(node);
        return node->value;
    }
    
    void put(int key, int value) {
        if (cache.count(key) == 0) {
            DLinkedNode* node = new DLinkedNode (key, value);
            cache[key] = node;
            addToHead(node);
            size++;
            //超出
            if (size > capacity) {
                DLinkedNode* removed = removeTail();
                cache.erase (removed->key);
                delete removed;
                size--;
            }
        } else {
            DLinkedNode* node = cache[key];
            node->value = value;
            moveToHead (node);
        }
    }

    void addToHead (DLinkedNode* node) {
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

    void removeNode (DLinkedNode* node) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

    void moveToHead (DLinkedNode* node) {
        removeNode (node);
        addToHead (node);
    }

    DLinkedNode* removeTail() {
        DLinkedNode* node = tail->prev;
        removeNode (node);
        return node;
    }
};

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

go

// go
// 使用原生的双向链表
type LRUCache struct {
    capacity int  
  size     int  
  cache    map[int]*list.Element  
  list     *list.List  
}

type DLinkedNode struct {  
  key   int  
  value int  
}  

func Constructor(capacity int) LRUCache {
    return LRUCache{  
    capacity: capacity,  
    size:     0,  
    cache:    make(map[int]*list.Element),  
    list:     list.New(),  
  }
}


func (this *LRUCache) Get(key int) int {
    if elem, ok := this.cache[key]; ok {  
    this.list.MoveToFront(elem)  
    return elem.Value.(*DLinkedNode).value  
  }  
  return -1
}


func (this *LRUCache) Put(key int, value int)  {
    if elem, ok := this.cache[key]; ok {  
    elem.Value.(*DLinkedNode).value = value  
    this.list.MoveToFront(elem)  
    return  
  }  
  
  newNode := &DLinkedNode{key: key, value: value}  
  elem := this.list.PushFront(newNode)  
  this.cache[key] = elem  
  this.size++  
  
  if this.size > this.capacity {  
    tailElem := this.list.Back()  
    if tailElem != nil {  
      this.list.Remove(tailElem)  
      delete(this.cache, tailElem.Value.(*DLinkedNode).key)  
      this.size--  
    }  
  }
}


/**
 * Your LRUCache object will be instantiated and called as such:
 * obj := Constructor(capacity);
 * param_1 := obj.Get(key);
 * obj.Put(key,value);
 */