Add LRU Cache implementation

sudheerj · sudheerj · commit d7eccd72b54b · 2024-11-01T23:31:49.000+08:00
diff --git a/README.md b/README.md
@@ -198,6 +198,7 @@ List of Programs related to data structures and algorithms
 |  6  | Longest consequtive sequence |[Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.md) |                                                                     Medium                                                                     | Find sequence using set or hash table |
 | 7 |   Valid Sudoku                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.md)                                                                                                                                                                                  | Medium       |    Using Map and Set methods                     |
 | 8 |   Letter combinations                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.md)                                                                                                                                                                                  | Medium       |    Backtracking with hash table mapping                 |
+| 9 |   LRU Cache                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.md)                                                                                                                                                                                  | Medium       |    Combination of Hash Table and doubly linked list                 |
 
 ## Sorting
 
diff --git a/src/java1/algorithms/hashmap/lruCache/LRUCache.java b/src/java1/algorithms/hashmap/lruCache/LRUCache.java
@@ -0,0 +1,84 @@
+package java1.algorithms.hashmap.lruCache;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Node {
+    Integer key;
+    Integer value;
+    Node next;
+    Node prev;
+
+    Node(Integer key, Integer value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+
+public class LRUCache {
+    int capacity;
+    Map<Integer, Node> cache;
+    Node head;
+    Node tail;
+    
+    LRUCache(int capacity){
+        this.capacity = capacity;
+        this.cache = new HashMap<>();
+        this.head = new Node(null, null);
+        this.tail = new Node(null, null);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+
+    public int get(int key){
+        if(this.cache.containsKey(key)) {
+            Node node = this.cache.get(key);
+            this._remove(node);
+            this._insert(node);
+            return node.value;
+        }
+
+        return -1;
+    }
+
+    public void set(int key, int value){
+        if(this.cache.containsKey(key)) {
+            this._remove(this.cache.get(key));
+        }
+
+        Node node = new Node(key, value);
+        this._insert(node);
+        this.cache.put(key, node);
+
+        if(this.cache.size() > this.capacity) {
+            Node lruNode = this.tail.prev;
+            this._remove(lruNode);
+            this.cache.remove(lruNode.key);
+        }
+    }
+
+    private void _remove(Node node){
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+
+    private void _insert(Node node) {
+        node.next = this.head.next;
+        node.prev = this.head;
+        this.head.next.prev = node;
+        this.head.next = node;
+    }
+
+    public static void main(String[] args) {
+        LRUCache lruCache = new LRUCache(2);
+        lruCache.set(1, 5);
+        System.out.println(lruCache.get(1));
+        lruCache.set(2, 10);
+        lruCache.set(3, 15);
+        System.out.println(lruCache.get(2));
+        lruCache.set(4, 20);
+        System.out.println(lruCache.get(1));
+    }
+}
+
+
diff --git a/src/java1/algorithms/hashmap/lruCache/LRUCache.md b/src/java1/algorithms/hashmap/lruCache/LRUCache.md
@@ -0,0 +1,52 @@
+**Problem statement:**
+Implement the **Least Recently Used (LRU) cache** class `LRUCache` with the following operations,
+ 1. `LRUCache(int capacity)` Initialize the LRU cache of positive size `capacity`.
+ 2. `int get(int key)` Return the value of the `key` if the `key` exists, otherwise return -1.
+ 3. `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 addition of the new key-value pair causes the cache to exceed its capacity, remove the least recently used key.
+ 
+
+**Note:** Each `get` and `put` needs to run in `O(1)` average time complexity.
+
+![Screenshot](../../../../images/lruCache.png)
+
+## Examples:
+Example 1:
+
+Input:
+["LRUCache", [2], "put", [1, 5],  "get", [1], "put", [2, 10], "put", [3, 15], "get", [2], "put", [4,20], "get", [1]]
+
+Output:
+[null, null, 5, null, null, 10, null, null, -1]
+
+Explanation:
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 5);  // cache: {1=5}
+lRUCache.get(1);      // return 5
+lRUCache.put(2, 10);  // cache: {1=5, 2=10}
+lRUCache.put(3, 15);  // cache: {2=10, 3=15}, key=1 was evicted
+lRUCache.get(2);      // returns 10 
+lRUCache.put(4, 20);  // cache: {3=15, 4=20}, key=2 was evicted
+lRUCache.get(1);      // return -1 (not found)
+
+
+**Algorithmic Steps**
+This problem is solved with the help of constant time lookups through hash map and ordered structured of doubly linked list data strcture. The hash map can provide get and put operations with `O(1)` time complexity, which is essential for LRU cache system. The algorithmic approach can be summarized as follows: 
+
+1. Create a node class(`Node`) to represent each entry in the cache. Each node will have a key, value, and pointers to the previous and next node.
+   
+2. Create a `LRUCache` class to manage the nodes and implementing the LRU Cache mechanism. 
+   
+3. The LRUCache class contains capacity of cache, cache hash map, and two dummy pointers named as head and tail nodes.
+    
+4. Initially head and tail nodes connected each other without any real nodes in between them. 
+   
+5. Create two internal methods `_remove` and `_insert` to use them with in get and set operations of LRU Cache. The remove method deletes the node from the doubly linked list. Whereas insert method is used to add a new node next to the head node. 
+
+6. Implement `get` method to fetch the node value from LRU cache. If the given key exists in cache, return the node value and increase the priority of the data in the LRU cache. Otherwise, return -1.
+   
+7. Implement `set` method to add key-value pair as an entry inside LRU cache. If the given key already exists in cache, update its value in the cache. Otherwise, add a key-value pair to the cache. Incase the number of keys exceeds the capacity of the LRU cache, evict the least recently used data.   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(1)` for both get and set methods. This is because accessing an item from hash map and updating its position in doubly linked list takes `O(1)` time complexity. In the same way, inserting an item inside hash map and adjusting the double linked list requires `O(1)` time complexity.
+
+Here, both hash map and double linked list requires `O(n)` space to store all the items in cache, where `n` is the capacity of cache.
diff --git a/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js b/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js
@@ -0,0 +1,67 @@
+class Node {
+    constructor(key, value){
+        this.key = key;
+        this.value = value;
+        this.head = null;
+        this.tail = null;
+    }
+}
+
+class LRUCache {
+    constructor(capacity){
+        this.capacity = capacity;
+        this.cache = new Map();
+        this.head = new Node(null, null);
+        this.tail = new Node(null, null);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+
+    get(key){
+        if(this.cache.has(key)) {
+            const node = this.cache.get(key);
+            this._remove(node);
+            this._insert(node);
+            return node.value;
+        }
+
+        return -1;
+    }
+
+    put(key, value) {
+        if(this.cache.has(key)) {
+            this._remove(this.cache.get(key));
+        }
+
+        const node = new Node(key, value);
+        this._insert(node);
+        this.cache.set(key, node);
+
+        if(this.cache.size > this.capacity){
+            const lruNode = this.tail.prev;
+            this._remove(lruNode);
+            this.cache.delete(lruNode.key);
+        }
+    }
+
+    _remove(node){
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+
+    _insert(node) {
+        node.next = this.head.next;
+        node.prev = this.head;
+        this.head.next.prev = node;
+        this.head.next = node;
+    }
+}
+
+let lruCache = new LRUCache(2);
+lruCache.put(1, 5);
+console.log(lruCache.get(1));
+lruCache.put(2, 10);
+lruCache.put(3, 15);
+console.log(lruCache.get(2));
+lruCache.put(4, 20);
+console.log(lruCache.get(1));
diff --git a/src/javascript/algorithms/hashtable/9.lruCache/lruCache.md b/src/javascript/algorithms/hashtable/9.lruCache/lruCache.md
@@ -0,0 +1,52 @@
+**Problem statement:**
+Implement the **Least Recently Used (LRU) cache** class `LRUCache` with the following operations,
+ 1. `LRUCache(int capacity)` Initialize the LRU cache of positive size `capacity`.
+ 2. `int get(int key)` Return the value of the `key` if the `key` exists, otherwise return -1.
+ 3. `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 addition of the new key-value pair causes the cache to exceed its capacity, remove the least recently used key.
+ 
+
+**Note:** Each `get` and `put` needs to run in `O(1)` average time complexity.
+
+![Screenshot](../../../../images/lruCache.png)
+
+## Examples:
+Example 1:
+
+Input:
+["LRUCache", [2], "put", [1, 5],  "get", [1], "put", [2, 10], "put", [3, 15], "get", [2], "put", [4,20], "get", [1]]
+
+Output:
+[null, null, 5, null, null, 10, null, null, -1]
+
+Explanation:
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 5);  // cache: {1=5}
+lRUCache.get(1);      // return 5
+lRUCache.put(2, 10);  // cache: {1=5, 2=10}
+lRUCache.put(3, 15);  // cache: {2=10, 3=15}, key=1 was evicted
+lRUCache.get(2);      // returns 10 
+lRUCache.put(4, 20);  // cache: {3=15, 4=20}, key=2 was evicted
+lRUCache.get(1);      // return -1 (not found)
+
+
+**Algorithmic Steps**
+This problem is solved with the help of constant time lookups through hash map and ordered structured of doubly linked list data strcture. The hash map can provide get and put operations with `O(1)` time complexity, which is essential for LRU cache system. The algorithmic approach can be summarized as follows: 
+
+1. Create a node class(`Node`) to represent each entry in the cache. Each node will have a key, value, and pointers to the previous and next node.
+   
+2. Create a `LRUCache` class to manage the nodes and implementing the LRU Cache mechanism. 
+   
+3. The LRUCache class contains capacity of cache, cache hash map, and two dummy pointers named as head and tail nodes.
+    
+4. Initially head and tail nodes connected each other without any real nodes in between them. 
+   
+5. Create two internal methods `_remove` and `_insert` to use them with in get and set operations of LRU Cache. The remove method deletes the node from the doubly linked list. Whereas insert method is used to add a new node next to the head node. 
+
+6. Implement `get` method to fetch the node value from LRU cache. If the given key exists in cache, return the node value and increase the priority of the data in the LRU cache. Otherwise, return -1.
+   
+7. Implement `set` method to add key-value pair as an entry inside LRU cache. If the given key already exists in cache, update its value in the cache. Otherwise, add a key-value pair to the cache. Incase the number of keys exceeds the capacity of the LRU cache, evict the least recently used data.   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(1)` for both get and set methods. This is because accessing an item from hash map and updating its position in doubly linked list takes `O(1)` time complexity. In the same way, inserting an item inside hash map and adjusting the double linked list requires `O(1)` time complexity.
+
+Here, both hash map and double linked list requires `O(n)` space to store all the items in cache, where `n` is the capacity of cache.
