leetcode ：LRU Cache

模仿最近最少使用的方法,题目的要求是构建一个数据结构，他支持两种操作，get和set操作，

set（key，value）是把对应的key和value记录进来；

get（key）是把key对应的value返回；

但是这个LRU Cache有一个容量capacity的限制，但记录进来的（key，value）值得个数超过容量capacity的限制

后，要把近期最少使用的（key，value）值删除掉。

我的做法时间复杂度可以达到O（1）的get和set，使用自定义的双向链表来记录插入的顺序，使用JDK自带的

HashMap达到get操作的O（1）时间复杂度，但删除的时候，使用的是双向链表，可以达到o（1）的删除

代码如下：

public class LRUCache {

    int capacity;
    int CurrentSize;

    private static class Node<K, V> {

        K key;
        V value;
        Node pre;
        Node next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            this.pre = null;
            this.next = null;
        }
    }

    private static class List<K, V> {

        Node<K, V> head = null;
        Node<K, V> tail = null;

        public List() {
        }

        public void addFirst(Node node) {
            if (this.head == null) {
                this.head = node;
                this.head.pre = null;
                this.head.next = null;
                this.tail = this.head;
            } else {
                node.pre = null;
                node.next = head;
                head.pre = node;
                this.head = node;
            }
        }

        public K remove(Node<K, V> node) {
            if (this.head == this.tail) {
                this.head = null;
                this.tail = null;
            } else if (node == this.head) {
                this.head = this.head.next;
                head.pre = null;
                node.next = null;
            } else if (node == this.tail) {
                this.tail = this.tail.pre;
                this.tail.next = null;
                node.pre = null;
                node.next = null;
            } else {
                Node pre = node.pre;
                Node next = node.next;
                pre.next = next;
                next.pre = pre;
                node.pre = node.next = null;
            }
            return node.key;
        }

        public K removeLast() {
            return this.remove(this.tail);
        }
    }
    HashMap<Integer, Node> map;
    List<Integer, Integer> list;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.CurrentSize = 0;
        this.list = new List<>();
        this.map = new HashMap<>();
    }

    public int get(int key) {
        Node node = this.map.get(key);
        if (node != null) {
            list.remove(node);
            node.pre = null;
            node.next = null;
            list.addFirst(node);
            return (int) node.value;
        }
        return -1;
    }

    public void set(int key, int value) {
        Node node = this.map.get(key);
        if(node != null){
            list.remove(node);
            node.key = key;
            node.value = value;
            list.addFirst(node);
        }
        else {
            if(this.CurrentSize < this.capacity){
                ++ this.CurrentSize;
            }
            else{
                int clearKey = list.removeLast();
                map.put(clearKey, null);
            }
            node = new Node(key,value);
            list.addFirst(node);
            map.put(key, node);
        }
    }

    // public static void main(String[] args) {
       
    // }
}