Merge pull request #72 from NEHA-AMIN/feature/lru-cache

Solution #146 -  Neha Amin - 16/07/2025

Author: JRS296

Stacks & Queues/#146 - LRU Cache -Medium/Explanation.md

@@ -0,0 +1,121 @@
+# 146. LRU Cache
+Difficulty: Medium  
+Category: HashMap, Doubly Linked List, Design  
+Leetcode Link: [Problem Link](https://leetcode.com/problems/lru-cache/)
+
+---
+
+## 📝 Introduction
+
+Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+Implement the LRUCache class:
+- LRUCache(int capacity) initializes the LRU cache with a positive size capacity.
+- int get(int key) returns the value of the key if the key exists, otherwise returns -1.
+- void put(int key, int value) updates the value of the key if it exists. Otherwise, adds the key-value pair to the cache. If the number of keys exceeds the capacity, evict the least recently used key.
+
+Both get and put must run in O(1) average time complexity.
+
+---
+
+## 💡 Approach & Key Insights
+
+To achieve O(1) time complexity for both get and put operations:
+- Use a HashMap to store key → pointer to node in a Doubly Linked List (DLL).
+- The DLL keeps track of the most recently used order, with:
+  - Head: Most recently used.
+  - Tail: Least recently used.
+- When a key is accessed or added:
+  - Move its node to the front (right after head).
+  - If capacity is exceeded, remove node from the end (before tail).
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+Explanation:  
+Use a LinkedList and linear search to implement put and get.  
+Too slow for O(1) requirement. Every access or insert may require O(N) time for searching.
+
+Time Complexity: O(N) per operation  
+Space Complexity: O(N) for storage
+
+Example/Dry Run:  
+get(1) — Scan entire list to find key = 1 → O(N)
+
+---
+
+### 2️⃣ Optimized Approach (HashMap + DLL)
+
+Explanation:  
+Use:
+- HashMap<int, Node*> to access nodes in O(1).
+- Doubly Linked List to maintain LRU order.
+
+Steps:
+- get(key):  
+  - If key exists → move node to head → return value.  
+  - Else → return -1.
+- put(key, value):  
+  - If key exists → update value → move node to head.  
+  - If not → insert new node → add to head.  
+  - If capacity exceeded → remove node from tail → erase from map.
+
+Time Complexity: O(1) for both get and put  
+Space Complexity: O(capacity)
+
+Example/Dry Run:  
+Input:
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]  
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]  
+Output: [null, null, null, 1, null, -1, null, -1, 3, 4]
+
+---
+
+### 3️⃣ Best / Final Optimized Approach (if applicable)
+
+Same as optimized. No better than O(1) per operation.
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach       | Time Complexity | Space Complexity |
+|----------------|------------------|------------------|
+| Brute Force    | O(N)             | O(N)             |
+| Optimized      | O(1)             | O(N)             |
+| Best Approach  | O(1)             | O(N)             |
+
+---
+
+## 📉 Optimization Ideas
+
+- Use a custom DLL instead of built-in collections for better control over node management.
+- Avoid unnecessary key re-insertion in hashmap.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+Capacity = 2  
+put(1,1) → cache = {1=1}  
+put(2,2) → cache = {1=1, 2=2}  
+get(1)   → return 1 → cache = {2=2, 1=1}  
+put(3,3) → evict 2 → cache = {1=1, 3=3}  
+get(2)   → return -1 (not found)  
+put(4,4) → evict 1 → cache = {3=3, 4=4}  
+get(1)   → return -1 (not found)  
+get(3)   → return 3  
+get(4)   → return 4
+
+---
+
+
+## 🔗 Additional Resources
+
+- [Stack Visualization Tool](https://visualgo.net/en/list)  
+
+Author: Neha Amin  
+Date: 19/07/2025

Stacks & Queues/#146 - LRU Cache -Medium/LRUCache.cpp

@@ -0,0 +1,70 @@
+class LRUCache {
+public:
+    class node {
+    public:
+        int key;
+        int val;
+        node *next;
+        node *prev;
+        node(int _key, int _val) {
+            key = _key;
+            val = _val;
+            next = nullptr;
+            prev = nullptr;
+        }
+    };
+
+    node *head = new node(-1, -1);
+    node *tail = new node(-1, -1);
+
+    int cap;
+    unordered_map<int, node*> m;
+
+    LRUCache(int capacity) {
+        cap = capacity;
+        head->next = tail;
+        tail->prev = head;
+    }
+
+    void addnode(node *newnode) {
+        node *temp = head->next;
+        newnode->next = temp;
+        newnode->prev = head;
+        head->next = newnode;
+        temp->prev = newnode;
+    }
+
+    void deletenode(node *delnode) {
+        node *delprev = delnode->prev;
+        node *delnext = delnode->next;
+        delprev->next = delnext;
+        delnext->prev = delprev;
+    }
+
+    int get(int key_) {
+        if (m.find(key_) != m.end()) {
+            node *resnode = m[key_];
+            int res = resnode->val;
+            m.erase(key_);
+            deletenode(resnode);
+            addnode(resnode);
+            m[key_] = head->next;
+            return res;
+        }
+        return -1;
+    }
+
+    void put(int key_, int value) {
+        if (m.find(key_) != m.end()) {
+            node *existingnode = m[key_];
+            m.erase(key_);
+            deletenode(existingnode);
+        }
+        if (m.size() == cap) {
+            m.erase(tail->prev->key);
+            deletenode(tail->prev);
+        }
+        addnode(new node(key_, value));
+        m[key_] = head->next;
+    }
+};

Stacks & Queues/#146 - LRU Cache -Medium/LRUCache.java

@@ -0,0 +1,70 @@
+class LRUCache {
+    class Node {
+        int key;
+        int val;
+        Node next;
+        Node prev;
+        
+        Node(int key, int val) {
+            this.key = key;
+            this.val = val;
+            this.next = null;
+            this.prev = null;
+        }
+    }
+    
+    Node head = new Node(-1, -1);
+    Node tail = new Node(-1, -1);
+    int cap;
+    HashMap<Integer, Node> cache;
+
+    public LRUCache(int capacity) {
+        cap = capacity;
+        cache = new HashMap<>();
+        head.next = tail;
+        tail.prev = head;
+    }
+    
+    private void addNode(Node newNode) {
+        Node temp = head.next;
+        newNode.next = temp;
+        newNode.prev = head;
+        head.next = newNode;
+        temp.prev = newNode;
+    }
+    
+    private void deleteNode(Node delNode) {
+        Node delPrev = delNode.prev;
+        Node delNext = delNode.next;
+        delPrev.next = delNext;
+        delNext.prev = delPrev;
+    }
+    
+    public int get(int key) {
+        if (cache.containsKey(key)) {
+            Node resNode = cache.get(key);
+            int result = resNode.val;
+            cache.remove(key);
+            deleteNode(resNode);
+            addNode(resNode);
+            cache.put(key, head.next);
+            return result;
+        }
+        return -1;
+    }
+    
+    public void put(int key, int value) {
+        if (cache.containsKey(key)) {
+            Node existingNode = cache.get(key);
+            cache.remove(key);
+            deleteNode(existingNode);
+        }
+        if (cache.size() == cap) {
+            Node lruNode = tail.prev;
+            cache.remove(lruNode.key);
+            deleteNode(lruNode);
+        }
+        addNode(new Node(key, value));
+        cache.put(key, head.next);
+    }
+}

Stacks & Queues/#146 - LRU Cache -Medium/LRUCache.py

@@ -0,0 +1,64 @@
+class LRUCache:
+    class Node:
+        def __init__(self, key=0, val=0):
+            self.key = key
+            self.val = val
+            self.next = None
+            self.prev = None
+
+    def __init__(self, capacity: int):
+        self.cap = capacity
+        self.cache = {}  # key -> node
+        
+        # Create dummy head and tail nodes
+        self.head = self.Node(-1, -1)
+        self.tail = self.Node(-1, -1)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+    def add_node(self, new_node):
+        """Add node right after head"""
+        temp = self.head.next
+        new_node.next = temp
+        new_node.prev = self.head
+        self.head.next = new_node
+        temp.prev = new_node
+
+    def delete_node(self, del_node):
+        """Remove node from the list"""
+        del_prev = del_node.prev
+        del_next = del_node.next
+        del_prev.next = del_next
+        del_next.prev = del_prev
+
+    def get(self, key: int) -> int:
+        if key in self.cache:
+            res_node = self.cache[key]
+            result = res_node.val
+            
+            # Move to head (mark as recently used)
+            del self.cache[key]
+            self.delete_node(res_node)
+            self.add_node(res_node)
+            self.cache[key] = self.head.next
+            
+            return result
+        return -1
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            # Update existing key
+            existing_node = self.cache[key]
+            del self.cache[key]
+            self.delete_node(existing_node)
+        
+        if len(self.cache) == self.cap:
+            # Remove LRU (tail.prev)
+            lru_node = self.tail.prev
+            del self.cache[lru_node.key]
+            self.delete_node(lru_node)
+        
+        # Add new node
+        new_node = self.Node(key, value)
+        self.add_node(new_node)
+        self.cache[key] = self.head.next