【算法】LRU缓存机制

class Node {
    int key, val;
    Node prev, next;
    Node(int key,int val) {
        this.key = key;
        this.val = val;
    }
}

// 构造一个双向链表
class MyLinkedList {
    private Node head,tail;
    private int size=0;
    MyLinkedList() {
        head = new Node(0,0);
        tail = new Node(0,0);
        head.next = tail;
        tail.prev = head;
    }

    /**
     * 链表尾部添加一个节点
     * @param node
     */
    public void addLast(Node node) {
        node.prev = tail.prev;
        node.next = tail;
        tail.prev.next = node;
        tail.prev = node;
        size++;
    }

    /**
     * 删除指定节点
     * @param node
     */
    public void deleteNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
    }

    public Node getFirstNode() {
        if (head.next == tail) return null;
        return head.next;
    }

    public int getSize() {
        return size;
    }
}


public class _146_LRU缓存机制 {

    Map<Integer, Node> map = null;
    MyLinkedList myLinkedList = null;
    int capacity;
    public _146_LRU缓存机制(int capacity) {
        map = new HashMap<>(capacity);
        myLinkedList = new MyLinkedList();
        this.capacity = capacity;
    }

    /**
     * 1. 根据key从hashbiao中获取链表上对应的Node，并返回对应的值
     * 2. 删除map和链表中对应的值和节点，并在链表最后的一个位置添加该值
     * @param key
     * @return
     */
    public int get(int key) {
        if (!map.containsKey(key)) return -1;
        Node node = map.get(key);
        myLinkedList.deleteNode(node);
        myLinkedList.addLast(node);
        return node.val;
    }

    /**
     * 1. 查重
     *      如果已经存在，则更新该节点的位置
     * 2. 检查容量
     *      若容量超出范围，则删除第一个节点
     * @param key
     * @param value
     */
    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            myLinkedList.deleteNode(node);
            node.val = value;
            myLinkedList.addLast(node);
            return;
        }
        if (myLinkedList.getSize() == capacity) {
            Node firstNode = myLinkedList.getFirstNode();
            map.remove(firstNode.key);
            myLinkedList.deleteNode(firstNode);
        }
        Node node = new Node(key,value);
        myLinkedList.addLast(node);
        map.put(key,node);
    }

    public static void main(String[] args) {
        _146_LRU缓存机制 cache = new _146_LRU缓存机制(2);
        cache.put(2,1);
        cache.put(2,2);
        System.out.println(cache.get(2));  // 2
    }
}