LRU算法实现

      1.lru缓存策略

      构成要素有两个:内存大小和替换策略.

      实现方法: hashtable+双向链表

      查询时间复杂度o(1),修改更新时间复杂度o(1).

      

      2.lru工作原理

      

    

    

1.题目地址:https://leetcode-cn.com/problems/lru-cache/
2.题目内容:LRU缓存机制(中等)

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

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

示例：
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

第一步:确定题目要实现的主要业务功能
第二步:实现业务功能的单元
第三步:组装实现业务功能的单元

4.lru(哈希表+双向链表)

public class Lru {
    // 1.定义双向链表
    class DoubleLinkNode {
        int key;
        int value;
        DoubleLinkNode prev;
        DoubleLinkNode next;

        public DoubleLinkNode() {}

        public DoubleLinkNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    // 2.定义哈希表
    private Map<Integer, DoubleLinkNode> cache = new HashMap<>();
    // 3.定义缓存数量,缓存容量
    private int size;
    private int capacity;
    // 4.定义头尾节点
    private DoubleLinkNode head;
    private DoubleLinkNode tail;

    public Lru(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 设置伪头部和尾部,非常巧妙
        head = new DoubleLinkNode();
        tail = new DoubleLinkNode();
        head.next = tail;
        tail.prev = head;
    }

    /**
     * 将节点写入头部
     * A-B-C,其中AC插入B,需要处理B的prv和next节点,C的prev,A的next
     */
    private void addToHead(DoubleLinkNode node) {
        node.prev = head;
        node.next = head.next;
        // 下面顺序不可颠倒 
        head.next.prev = node;
        head.next = node;
    }

    /**
     * 删除结点
     * A-B-C,其中ABC删除B,需要处理A的next和c的prev
     */
    private void removeNode(DoubleLinkNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    /**
     * 移动到头结点
     * A-B-C,其中AC插入B,需要处理B的prv和next节点,A的next,C的prev
     */
    private void moveToHead(DoubleLinkNode node) {
        removeNode(node);
        addToHead(node);
    }
    
    /**
     * 删除尾结点
     * @return DoubleLinkNode
     */
    private DoubleLinkNode removeTail() {
        DoubleLinkNode node = tail.prev;
        removeNode(node);
        return node;
    }
    
    /**
     * 获取缓存值
     * @param key
     */
    public int get(int key) {
        DoubleLinkNode node = cache.get(key);
        if (node == null) {
            return -1;
        } else {
            addToHead(node);
            return node.value;
        }
    }
    
    /**
     * 保存缓存值
     * @param key
     */
    public void put(int key, int value) {
        DoubleLinkNode node = cache.get(key);
        // 如果节点存在
        if (node != null) {
            node.value = value;
            moveToHead(node);
        } else {
            // 创建新节点,添加到hash表中
            DoubleLinkNode newNode = new DoubleLinkNode(key, value);
            cache.put(key, newNode);
            // 移动到双向链表头部
            moveToHead(newNode);
            size++;
            if (size > capacity) {
                // hash表超出容量
                DoubleLinkNode tail = removeTail();
                cache.remove(tail.key);
                size--;
            }
        }
    }
}