面试高频题： 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

思路：hash+双链表

//get和put操作需要在0(1)复杂度完成


type LRUCache struct {
    size int    //大小
    capacity int  //容量
    cache map[int]*DLinkedNode  //哈希表
    head, tail *DLinkedNode //双链表
}

type DLinkedNode struct {
    key, value int    //key和value 是put传过来，就相当于缓存key-value
    prev, next *DLinkedNode
}

//初始化一个节点
func initDLinkedNode(key, value int) *DLinkedNode {
    return &DLinkedNode{
        key: key,
        value: value,
    }
}

//初始化一个双向链表
func Constructor(capacity int) LRUCache {
    l := LRUCache{
        cache: map[int]*DLinkedNode{},
        head: initDLinkedNode(0, 0),
        tail: initDLinkedNode(0, 0),
        capacity: capacity,
    }
    l.head.next = l.tail
    l.tail.prev = l.head
    return l
}

//获取数据
func (this *LRUCache) Get(key int) int {
    if _, ok := this.cache[key]; !ok {
        return -1
    }

   //cache是哈希表
    node := this.cache[key]
    //链表记录顺序 
    this.moveToHead(node)
    return node.value
}

//写入数据
func (this *LRUCache) Put(key int, value int)  {
    if _, ok := this.cache[key]; !ok {
        //不存在
        node := initDLinkedNode(key, value)
        this.cache[key] = node
        this.addToHead(node)
        this.size++
        if this.size > this.capacity {
            removed := this.removeTail()
            delete(this.cache, removed.key)
            this.size--
        }
    } else {
        //存在 
        node := this.cache[key]
        node.value = value
        this.moveToHead(node)
    }
}

//头部增加节点
func (this *LRUCache) addToHead(node *DLinkedNode) {
    node.prev = this.head
    node.next = this.head.next
    this.head.next.prev = node
    this.head.next = node
}

//删除节点
func (this *LRUCache) removeNode(node *DLinkedNode) {
    node.prev.next = node.next
    node.next.prev = node.prev
}

//将该节点移到头部
func (this *LRUCache) moveToHead(node *DLinkedNode) {
    this.removeNode(node)
    this.addToHead(node)
}

//移除尾部节点
func (this *LRUCache) removeTail() *DLinkedNode {
    node := this.tail.prev
    this.removeNode(node)
    return node
}

hash访问key，value快，链表保存顺序。每次新增节点，将节点放到链表首部，还要判断LRU的容量确定是否删除队尾节点。

 

参考地址：https://leetcode-cn.com/problems/lru-cache/solution/lruhuan-cun-ji-zhi-by-