LC.146 实现LRU机制

通过双向链表加HashMap实现LRU
1.先实现一个Node节点类

class Node{
    int key;
    int val;
    Node pre;
    Node next;
    public Node(int key,int val){
        this.key = key;
        this.val = val;
        this.pre = null;
        this.next = null;
    }
}

再接着实现双向链表

class DoubleList{
    Node head;
    Node tail;
    public DoubleList(){
        head = new Node(-1,-1);
        tail = new Node(-1,-1);
        head.next = tail;
        tail.pre = head;
    }
    public void addFirst(Node node){
        node.next = head.next;
        head.next.pre = node;
        node.pre = head;
        head.next = node;
    }
    public void delete(Node node){
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    public int deleteLast(){
        if(tail.pre==head){
            //如果没有节点 则删除失败
            return -1;
        }
        Node node = tail.pre;
        int key = node.key;
        this.delete(node);
        return key;
    }
}

之后在LRU类中 通过调用Doublelist 并创建HashMap实现LRU机制

class LRUCache {
    HashMap<Integer,Node> hm;//key 为int val 为Node 节点
    DoubleList dl;
    int capacity;

    public LRUCache(int capacity) {
        hm = new HashMap();
        dl = new DoubleList();
        this.capacity = capacity;

    }
    
    public int get(int key) {
        if(!hm.containsKey(key)){
            return -1;
        }
        //如果存在 则把该节点删除  再重新加入LRU中
        Node node = hm.get(key);
        this.put(key,node.val);
        return node.val;

    }
    
    public void put(int key, int value) {
        Node node = new Node(key,value);
        if(hm.containsKey(key)){
            //重复直接删掉
            dl.delete(hm.get(key));
        }else if(hm.size()==capacity){
            // 满了 则删除最后一个，同时更新HashMap;
            int k = dl.deleteLast();
            hm.remove(k);
        }
        //最后加入到最前面，并更新HashMap
        dl.addFirst(node);
        hm.put(key,node);
    }
}