LRU内存淘汰算法

前提:使用HashMap+双向链表形式实现LRU缓存管理算法

public class _146_LRUCache {

    private final HashMap<Integer, DNode> cache;
    //容量
    int cap;
    //当前大小
    int size;
    DNode head;
    DNode tail;
    //为了保证get为O(1),使用map作为cache
    public _146_LRUCache(int cap) {
        this.cap = cap;
        this.size = 0;
        cache = new HashMap<>();
        this.head = new DNode();
        this.tail = new DNode();
        head.next = tail;
        tail.prev = head;
    }

    class DNode{

        int key;
        int value;

        DNode prev;
        DNode next;
        public DNode(){}
        public DNode(int key,int val) {
            this.key = key;
            this.value = val;
        }

    }

    public void put(int key,int value) {
        DNode isExistNode = cache.get(key);
        DNode dNode = new DNode(key, value);
        if (isExistNode != null){
            cache.put(key,dNode);
            //移动到头部:1.先删除 2.添加到头部
            moveToHead(isExistNode);
            return;
//            return cache.get(key);
        }
        cache.put(key,dNode);
        size++;
        //添加到头部
        addToHead(dNode);
        //超过最大容量,需要删除
        if (size>cap){
//            moveToHead(dNode);
            //删除缓存
            cache.remove(tail.prev.key);
            //删除尾部节点(可以复用删除逻辑)
            delNode(tail.prev);
//            tail.prev = tail.prev.prev;
//            tail.prev.prev.next = tail;
            size--;
        }
    }

    private void moveToHead(DNode isExistNode) {
        //1.删除逻辑
            delNode(isExistNode);
        //2.添加到头部
            addToHead(isExistNode);
    }

    private void delNode(DNode isExistNode) {
        isExistNode.prev.next= isExistNode.next;
        isExistNode.next.prev = isExistNode.prev;
    }

    private void addToHead(DNode dNode) {

        dNode.next= head.next;
        dNode.prev = head;

        head.next.prev = dNode;
        head.next = dNode;
    }

    public int get(int key) {
        DNode dNode = cache.get(key);
        if (dNode == null){
            return -1;
        }
        moveToHead(dNode);
        return dNode.value;
    }
}

总结:HashMap使其查找为O(1),更新时候是在链表操作的,使其更新操作为O(1),每次访问其中任何一个节点的时候,移动node节点