[LeetCode 146] LRU Cache

Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.

Implement the LRUCache class:

  • LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
  • int get(int key) Return the value of the key if the key exists, otherwise return -1.
  • void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.

The functions get and put must each run in O(1) average time complexity.

Example 1:

["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
[null, null, null, 1, null, -1, null, -1, 3, 4]

LRUCache lRUCache = new LRUCache(2); 
lRUCache.put(1, 1); // cache is {1=1} 
lRUCache.put(2, 2); // cache is {1=1, 2=2} 
lRUCache.get(1);    // return 1 
lRUCache.put(3, 3); // LRU key was 2, evicts key 2, cache is {1=1, 3=3} lRUCache.get(2);    // returns -1 (not found) 
lRUCache.put(4, 4); // LRU key was 1, evicts key 1, cache is {4=4, 3=3} lRUCache.get(1);    // return -1 (not found) 
lRUCache.get(3);    // return 3 
lRUCache.get(4);    // return 4


  • 1 <= capacity <= 3000
  • 0 <= key <= 104
  • 0 <= value <= 105
  • At most 2 * 105 calls will be made to get and put.


Approach 1: Ordered dictionary


We’re asked to implement the structure which provides the following operations in \mathcal{O}(1) time :

  • Get the key / Check if the key exists
  • Put the key
  • Delete the first added key

The first two operations in \mathcal{O}(1) time are provided by the standard hashmap, and the last one – by linked list.

There is a structure called ordered dictionary, it combines behind both hashmap and linked list. In Python this structure is called OrderedDict and in Java LinkedHashMap.

Let’s use this structure here.


from collections import OrderedDict
class LRUCache(OrderedDict):

    def __init__(self, capacity):
        self.capacity = capacity

    def get(self, key):
        if key not in self:
            return -1
        return self[key]

    def put(self, key, value):
        if key in self:
        self[key] = value
        if len(self) > self.capacity:
            self.popitem(last = False)

Complexity Analysis

  • Time complexity : \mathcal{O}(1) both for put and get since all operations with ordered dictionary : get/in/set/move_to_end/popitem (get/containsKey/put/remove) are done in a constant time.
  • Space complexity : \mathcal{O}(capacity) since the space is used only for an ordered dictionary with at most capacity + 1 elements.

Approach 2: Hashmap + DoubleLinkedList


This Java solution is an extended version of the the article published on the Discuss forum.

The problem can be solved with a hashmap that keeps track of the keys and its values in the double linked list. That results in \mathcal{O}(1)O(1) time for put and get operations and allows to remove the first added node in \mathcal{O}(1)O(1) time as well.


One advantage of double linked list is that the node can remove itself without other reference. In addition, it takes constant time to add and remove nodes from the head or tail.

One particularity about the double linked list implemented here is that there are pseudo head and pseudo tail to mark the boundary, so that we don’t need to check the null node during the update.



class DLinkedNode(): 
    def __init__(self):
        self.key = 0
        self.value = 0
        self.prev = None = None
class LRUCache():
    def _add_node(self, node):
        Always add the new node right after head.
        node.prev = self.head = = node = node

    def _remove_node(self, node):
        Remove an existing node from the linked list.
        prev = node.prev
        new = = new
        new.prev = prev

    def _move_to_head(self, node):
        Move certain node in between to the head.

    def _pop_tail(self):
        Pop the current tail.
        res = self.tail.prev
        return res

    def __init__(self, capacity):
        :type capacity: int
        self.cache = {}
        self.size = 0
        self.capacity = capacity
        self.head, self.tail = DLinkedNode(), DLinkedNode() = self.tail
        self.tail.prev = self.head

    def get(self, key):
        :type key: int
        :rtype: int
        node = self.cache.get(key, None)
        if not node:
            return -1

        # move the accessed node to the head;

        return node.value

    def put(self, key, value):
        :type key: int
        :type value: int
        :rtype: void
        node = self.cache.get(key)

        if not node: 
            newNode = DLinkedNode()
            newNode.key = key
            newNode.value = value

            self.cache[key] = newNode

            self.size += 1

            if self.size > self.capacity:
                # pop the tail
                tail = self._pop_tail()
                del self.cache[tail.key]
                self.size -= 1
            # update the value.
            node.value = value

Complexity Analysis

  • Time complexity : \mathcal{O}(1) both for put and get.
  • Space complexity : \mathcal{O}(capacity) since the space is used only for a hashmap and double linked list with at most capacity + 1 elements.

Leave a reply