feat: Implement LRU Cache algorithm

Author: maynkxx

data_structures/lru_cache.py

@@ -0,0 +1,72 @@
+"""
+An implementation of a Least Recently Used (LRU) Cache.
+... (the rest of the docstring is the same)
+"""
+from __future__ import annotations
+from typing import Optional
+
+class Node:
+    """A node in the doubly linked list."""
+    def __init__(self, key: int, val: int) -> None:
+        self.key, self.val = key, val
+        self.prev: Optional[Node] = None
+        self.next: Optional[Node] = None
+
+class LRUCache:
+    """
+    A Least Recently Used (LRU) Cache data structure.
+    ... (the doctests are the same)
+    """
+    def __init__(self, capacity: int) -> None:
+        if capacity <= 0:
+            raise ValueError("Capacity must be a positive integer.")
+        self.capacity = capacity
+        self.cache: dict[int, Node] = {}  # Maps key to node
+
+        self.head = Node(-1, -1)
+        self.tail = Node(-1, -1)
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+    def _remove(self, node: Node) -> None:
+        """Helper to remove a node from the list."""
+        if node.prev and node.next:
+            prev, nxt = node.prev, node.next
+            prev.next = nxt
+            nxt.prev = prev
+
+    def _add(self, node: Node) -> None:
+        """Helper to add a node to the front of the list (most recent)."""
+        if self.head.next:
+            node.prev = self.head
+            node.next = self.head.next
+            self.head.next.prev = node
+            self.head.next = node
+
+    def get(self, key: int) -> int:
+        if key in self.cache:
+            node = self.cache[key]
+            self._remove(node)
+            self._add(node)
+            return node.val
+        return -1
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            node = self.cache[key]
+            node.val = value
+            self._remove(node)
+            self._add(node)
+        else:
+            new_node = Node(key, value)
+            self.cache[key] = new_node
+            self._add(new_node)
+
+            if len(self.cache) > self.capacity and self.tail.prev:
+                lru = self.tail.prev
+                self._remove(lru)
+                del self.cache[lru.key]
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()