lru缓存策略

  class ListNode {
      int val;
      int key;
      ListNode next;
      ListNode pre;
      ListNode(int x, int y) {
          key = x;
          val = y;
          next = null;
          pre = null;
      }
 }
  class HListNode {
      int len;
      ListNode head;
      ListNode tail;
    
    HListNode(){
        head = null;
        tail = null;
        len = 0;
    }
    
    public int get(int key, ListNode[] no){
        ListNode temp_head = head;
        while (temp_head != null) {
            if (temp_head.key == key) {
                no[0] = temp_head;
                return temp_head.val;
            } else {
                temp_head = temp_head.next;
            }
        }
        return -1;
    }
    
    public void delNode(ListNode node){
        if (node == null) {
            return;
        } else {
            if (node.pre != null) {
                node.pre.next = node.next;
            } else {
                head = node.next;
            }
            if (node.next != null) {
                node.next.pre = node.pre;
            } else {
                tail = node.pre;
            }
            len--;
            node.next = null;
            node.pre = null;
        }
    }
    
    
    public void addNodeBeforeHead(ListNode node){
        if (node == null) {
            return;
        }
        if (head == null) {
            head = node;
            tail = node;
            len++;
        } else {
            node.next = head;
            head.pre = node;
            head = node;
            len++;
        }
    }
      
    public void addBeforeHead(int key, int val){
        ListNode temp_node = new ListNode(key, val);
        if (head == null) {
            head = temp_node;
            tail = temp_node;
        } else {
            temp_node.next = head;
            head.pre = temp_node;
            head = temp_node;
        }
        len++;
    }
    
    public ListNode isHasKey(int key){
        ListNode temp_head = head;
        while (temp_head != null) {
            if (temp_head.key == key) {
                return temp_head;
            } else {
                temp_head = temp_head.next;
            }
        }
        return null;
    }
    
    public void delAfterTail(){
          if (tail == null) {
            return;
          } else {
              if (tail.pre == null) {
                head = null;
                tail = null;
                len = 0;
              } else {
                tail = tail.pre;
                tail.next = null;    
                len--;
              }
              
          }
    }
 }
public class LRUCache {
    int capacity;
    HListNode Hnode = new HListNode(); 
    /*
    * @param capacity: An integer
    */public LRUCache(int capacity) {
        // do intialization if necessary
        this.capacity = capacity;
    }

    /*
     * @param key: An integer
     * @return: An integer
     */
    public int get(int key) {
        // write your code here
        ListNode[] no = new ListNode[1];
        int val = Hnode.get(key, no);
        if (val != -1) {
            Hnode.delNode(no[0]);
            Hnode.addNodeBeforeHead(no[0]);
        }
        return val;
    }

    /*
     * @param key: An integer
     * @param value: An integer
     * @return: nothing
     */
    public void set(int key, int value) {
        // write your code here
        ListNode no = Hnode.isHasKey(key);
        if (no != null) {
            Hnode.delNode(no);
        }
        if (Hnode.len >= capacity) {
            Hnode.delAfterTail();
        }
        Hnode.addBeforeHead(key ,value);
    }
}

lru规则简介：

总容量有限，插入时发现已经有这个key了，就需要把这个key  value更新，并且放到最前面。 如果发现容量满了，那么就删除最后的元素。

每次读取某一个元素之后就把该元素挪到最前面。

我的思路：

基础数据结构是双端链表

然后新建一个数据结构，里面有head  tail分别指向双端链表的头和尾，len用来表示这个链表的长度，然后写一些这个数据结构增删改查的API，就简单了。