zoukankan      html  css  js  c++  java
  • 146. LRU Cache

    Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put.

    get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
    put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

    The cache is initialized with a positive capacity.

    Follow up:
    Could you do both operations in O(1) time complexity?

    Example:

    LRUCache cache = new LRUCache( 2 /* capacity */ );
    
    cache.put(1, 1);
    cache.put(2, 2);
    cache.get(1);       // returns 1
    cache.put(3, 3);    // evicts key 2
    cache.get(2);       // returns -1 (not found)
    cache.put(4, 4);    // evicts key 1
    cache.get(1);       // returns -1 (not found)
    cache.get(3);       // returns 3
    cache.get(4);       // returns 4
    
    
    class LRUCache {
        private Map<Integer, Integer> map;
        private int capacity;
        public LRUCache(int capacity) {
            this.capacity = capacity;
            map = new LinkedHashMap<Integer, Integer>();
        }
        
        public int get(int key) {
            Integer val = map.get(key);
            if (val == null) return -1;
            map.remove(key);
            map.put(key, val);//确保get后当前key变成最后一个插入的
            return val;
        }
        
        public void put(int key, int value) {
            map.remove(key);//Why? Because假如update键的新value也算作visited,要先把当前key删掉重新insert确保是最后一个插入的
            map.put(key, value);
            if (map.size() > capacity){
                // for(Map.Entry<Integer, Integer> entry: map.entrySet()){
                //     System.out.println("key"+entry.getKey()+"value"+entry.getValue());
                // }
                map.remove(map.entrySet().iterator().next().getKey());
            }
        }
    }
    
    /**
     * Your LRUCache object will be instantiated and called as such:
     * LRUCache obj = new LRUCache(capacity);
     * int param_1 = obj.get(key);
     * obj.put(key,value);
     */
    
    
    
     

    来自小土刀大神,短小精悍,用了LinkedHashMap的特性(保留插入顺序)。

    get的时候先取出value,然后重新插入确保这个key是最后一个值。

    put的时候也是要先remove了再重新put进去保证update键的情况

    class LRUCache {
      
      Node head = new Node(0, 0), tail = new Node(0, 0);
      Map<Integer, Node> map = new HashMap();
      int capacity;
      
      public LRUCache(int _capacity) {
        capacity = _capacity;
        head.next = tail;
        tail.prev = head;
      }
    
      public int get(int key) {
        if(map.containsKey(key)) {
          Node node = map.get(key);
          remove(node);
          insert(node);
          return node.value;
        } else {
          return -1;
        }
      }
    
      public void put(int key, int value) {
        if(map.containsKey(key)) {
          remove(map.get(key));
        }
        if(map.size() == capacity) {
          remove(tail.prev);
        }
        insert(new Node(key, value));
      }
      
      private void remove(Node node) {
        map.remove(node.key);
        node.prev.next = node.next;
        node.next.prev = node.prev;
      }
      
      private void insert(Node node){
        map.put(node.key, node);
        Node headNext = head.next;
        head.next = node;
        node.prev = head;
        headNext.prev = node;
        node.next = headNext;
      }
      
      class Node{
        Node prev, next;
        int key, value;
        Node(int _key, int _value) {
          key = _key;
          value = _value;
        }
      }
    }

    用linkedhashmap太赖了,用一般hashmap估计能报名

    原理:Node:prev,next,key,val

    然后用一个头节点head,尾节点tail执行insert和remove操作,insert每次加到最前边,也就是head。next。remove每次把tail.prev移除掉,注意更新节点的prev,next

  • 相关阅读:
    hihocoder 1049 后序遍历
    hihocoder 1310 岛屿
    Leetcode 63. Unique Paths II
    Leetcode 62. Unique Paths
    Leetcode 70. Climbing Stairs
    poj 3544 Journey with Pigs
    Leetcode 338. Counting Bits
    Leetcode 136. Single Number
    Leetcode 342. Power of Four
    Leetcode 299. Bulls and Cows
  • 原文地址:https://www.cnblogs.com/wentiliangkaihua/p/11756743.html
Copyright © 2011-2022 走看看