leetcode 146. LRU缓存机制

题:

---

思路:
相当于自己定义一个带时间限制的treeMap 比较大小通过最后一次访问时间来判断
map的底层显然是用链表实现的

    1.put操作
        遍历队列，看看是否已经存在这个key
            如果已经存在，则找到位置并更新value，然后将该结点移至队列头
            如果不存在
                如果容量没满
                    直接头插
                如果容量满了
                    直接更新队列尾结点的key和value，然后移动至表头
    2.get操作
        遍历队列，如果没找到，返回-1
        如果找到了，返回value，并将该结点移至队列头

---

码：

class LRUCache {
    // 相当于自己定义一个带时间限制的treeMap 比较大小通过最后一次访问时间来判断
    // map的底层显然是用链表实现的
    /*
        1.put操作
            遍历队列，看看是否已经存在这个key
                如果已经存在，则找到位置并更新value，然后将该结点移至队列头
                如果不存在
                    如果容量没满
                        直接头插
                    如果容量满了
                        直接更新队列尾结点的key和value，然后移动至表头
        2.get操作
            遍历队列，如果没找到，返回-1
            如果找到了，返回value，并将该结点移至队列头
    */
    class Node{
        int key;
        int value;
        Node pre;
        Node post;
        Node(int key , int value){
            this.key = key;
            this.value = value;
            pre = null;
            post = null;
        }
    }
    Node head;
    Node trail;
    private int capacity;
    private int curCapacity;
    

    public LRUCache(int capacity) {
        this.capacity = capacity;
        curCapacity = 0;
        head = null;
        trail = null;
    }
    
    public int get(int key) {
        Node p = head;
        while(p!=null){
            if(key == p.key)
                break;
            p = p.post;
        }
        if(p!=null){
            // 说明这个key已经存在
            // 如果已经是表头，则无需移动
            if(head != p){
                // 将p移动至表头
                Node q = p.post;
                Node r = p.pre;
                p.post = head;
                p.pre = null;
                r.post = q;// q可以为null
                if(q!=null)
                    q.pre = r;
                else 
                    trail = r;
                head.pre = p;
                head = p;
            }
            return p.value;
        }
        else{
            return -1;
        }
    }
    
    public void put(int key, int value) {
        if(curCapacity == 0){
            Node node = new Node(key,value);
            head = node;
            trail = node;
            curCapacity++;
            return ;
        }

        Node p = head;
        while(p!=null){
            if(key == p.key)
                break;
            p = p.post;
        }
        if(p!=null){
            // 说明这个key已经存在
            p.value = value;
            // 如果已经是表头，则无需移动
            if(head != p){
                // 将p移动至表头
                Node q = p.post;
                Node r = p.pre;
                p.post = head;
                p.pre = null;
                r.post = q;// q可以为null
                if(q!=null)
                    q.pre = r;
                else 
                    trail = r;
                head.pre = p;
                head = p;
            }

        }else{
            // 不存在key，如果容量没满则直接头插
            if(curCapacity < capacity){
                Node node = new Node(key,value);
                node.post = head;
                head.pre = node;
                head = node;
            }else{
                // 直接更新队尾，然后移至表头
                trail.key = key;
                trail.value = value;
                trail.post = head;
                head.pre = trail;
                Node a = trail;
                trail = trail.pre;
                a.pre = null;
                trail.post = null;
                head = a;
            }
            curCapacity++;
        }
        
    }
}