feat: add DoublyListNode

Author: wislertt

leetcode/lru_cache/solution.py

@@ -1,5 +1,7 @@
 from collections import OrderedDict
 
+from leetcode_py.data_structures.doubly_list_node import DoublyListNode
+
 
 class LRUCache:
     # Space: O(capacity)
@@ -31,3 +33,76 @@ def put(self, key: int, value: int) -> None:
                 self.cache.popitem(last=False)
 
             self.cache[key] = value
+
+
+class CacheNode(DoublyListNode[int]):
+    def __init__(self, key: int = 0, val: int = 0) -> None:
+        super().__init__(val)
+        self.key = key
+
+
+class LRUCacheWithDoublyList:
+    def __init__(self, capacity: int) -> None:
+        self.capacity = capacity
+        self.cache: dict[int, CacheNode] = {}
+
+        # Dummy head and tail nodes
+        self.head = CacheNode()
+        self.tail = CacheNode()
+        self.head.next = self.tail
+        self.tail.prev = self.head
+
+    def _add_node(self, node: CacheNode) -> None:
+        """Add node right after head"""
+        node.prev = self.head
+        node.next = self.head.next
+        if self.head.next:
+            self.head.next.prev = node
+        self.head.next = node
+
+    def _remove_node(self, node: CacheNode) -> None:
+        """Remove node from list"""
+        if node.prev:
+            node.prev.next = node.next
+        if node.next:
+            node.next.prev = node.prev
+
+    def _move_to_head(self, node: CacheNode) -> None:
+        """Move node to head (most recent)"""
+        self._remove_node(node)
+        self._add_node(node)
+
+    def _pop_tail(self) -> CacheNode:
+        """Remove last node before tail"""
+        last_node = self.tail.prev
+        assert isinstance(last_node, CacheNode), "Expected CacheNode"
+        self._remove_node(last_node)
+        return last_node
+
+    def get(self, key: int) -> int:
+        node = self.cache.get(key)
+        if not node:
+            return -1
+
+        # Move to head (most recent)
+        self._move_to_head(node)
+        return node.val
+
+    def put(self, key: int, value: int) -> None:
+        node = self.cache.get(key)
+
+        if node:
+            # Update existing
+            node.val = value
+            self._move_to_head(node)
+        else:
+            # Add new
+            new_node = CacheNode(key, value)
+
+            if len(self.cache) >= self.capacity:
+                # Remove LRU
+                tail = self._pop_tail()
+                del self.cache[tail.key]
+
+            self.cache[key] = new_node
+            self._add_node(new_node)

leetcode/lru_cache/tests.py

@@ -2,27 +2,44 @@
 
 from leetcode_py.test_utils import logged_test
 
-from .solution import LRUCache
+from .solution import LRUCache, LRUCacheWithDoublyList
 
 
 class TestLRUCache:
+    @pytest.mark.parametrize("lru_class", [LRUCache, LRUCacheWithDoublyList])
     @pytest.mark.parametrize(
         "operations, inputs, expected",
         [
             (
                 ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"],
                 [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]],
                 [None, None, None, 1, None, -1, None, -1, 3, 4],
-            )
+            ),
+            (
+                ["LRUCache", "get", "put", "get", "put", "put", "get", "get"],
+                [[2], [2], [2, 6], [1], [1, 5], [1, 2], [1], [2]],
+                [None, -1, None, -1, None, None, 2, 6],
+            ),
+            (
+                ["LRUCache", "put", "get", "put", "get", "get"],
+                [[1], [2, 1], [2], [3, 2], [2], [3]],
+                [None, None, 1, None, -1, 2],
+            ),
         ],
     )
     @logged_test
-    def test_lru_cache(self, operations: list[str], inputs: list[list[int]], expected: list[int | None]):
-        cache: LRUCache | None = None
+    def test_lru_cache(
+        self,
+        lru_class: type[LRUCache | LRUCacheWithDoublyList],
+        operations: list[str],
+        inputs: list[list[int]],
+        expected: list[int | None],
+    ):
+        cache = None
         results: list[int | None] = []
         for i, op in enumerate(operations):
             if op == "LRUCache":
-                cache = LRUCache(inputs[i][0])
+                cache = lru_class(inputs[i][0])
                 results.append(None)
             elif op == "get" and cache is not None:
                 results.append(cache.get(inputs[i][0]))

leetcode_py/data_structures/doubly_list_node.py

@@ -0,0 +1,128 @@
+from typing import Generic, TypeVar
+
+# TODO: Remove TypeVar when minimum Python version is 3.12+ (use class DoublyListNode[T]: syntax)
+T = TypeVar("T")
+
+
+class DoublyListNode(Generic[T]):
+    def __init__(
+        self, val: T, prev: "DoublyListNode[T] | None" = None, next: "DoublyListNode[T] | None" = None
+    ):
+        self.val = val
+        self.prev = prev
+        self.next = next
+
+    @classmethod
+    def from_list(cls, arr: list[T]) -> "DoublyListNode[T] | None":
+        if not arr:
+            return None
+        head = cls(arr[0])
+        current = head
+        for val in arr[1:]:
+            new_node = cls(val, prev=current)
+            current.next = new_node
+            current = new_node
+        return head
+
+    def _has_cycle(self) -> bool:
+        """Detect cycle using Floyd's algorithm in forward direction."""
+        slow = fast = self
+        while fast and fast.next and fast.next.next:
+            assert slow.next is not None
+            slow = slow.next
+            fast = fast.next.next
+            if slow is fast:
+                return True
+        return False
+
+    def to_list(self, max_length: int = 1000) -> list[T]:
+        result: list[T] = []
+        current: "DoublyListNode[T] | None" = self
+        visited: set[int] = set()
+
+        while current and len(result) < max_length:
+            if id(current) in visited:
+                break
+            visited.add(id(current))
+            result.append(current.val)
+            current = current.next
+        return result
+
+    def __str__(self) -> str:
+        if self._has_cycle():
+            result: list[str] = []
+            current: "DoublyListNode[T] | None" = self
+            visited: dict[int, int] = {}
+            position = 0
+
+            while current:
+                if id(current) in visited:
+                    cycle_pos = visited[id(current)]
+                    cycle_val = result[cycle_pos]
+                    result_str = " <-> ".join(result)
+                    return f"{result_str} <-> ... (cycle back to {cycle_val})"
+
+                visited[id(current)] = position
+                result.append(str(current.val))
+                current = current.next
+                position += 1
+
+        values = self.to_list()
+        result_str = " <-> ".join(str(val) for val in values)
+        if len(values) >= 1000:
+            result_str += " <-> ... (long list)"
+        return result_str
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.to_list()})"
+
+    def _repr_html_(self) -> str:
+        """Generate HTML representation with bidirectional arrows."""
+        try:
+            import graphviz
+        except ImportError:
+            return f"<pre>{self.__str__()}</pre>"
+
+        dot = graphviz.Digraph(comment="DoublyLinkedList")
+        dot.attr(rankdir="LR")
+        dot.attr("node", shape="box", style="rounded,filled", fillcolor="lightgreen")
+        dot.attr("edge", color="black")
+
+        current: "DoublyListNode[T] | None" = self
+        visited: dict[int, int] = {}
+        node_id = 0
+
+        while current:
+            if id(current) in visited:
+                cycle_target = visited[id(current)]
+                dot.edge(
+                    f"node_{node_id - 1}",
+                    f"node_{cycle_target}",
+                    color="red",
+                    style="dashed",
+                    label="cycle",
+                )
+                break
+
+            visited[id(current)] = node_id
+            dot.node(f"node_{node_id}", str(current.val))
+
+            if current.next and id(current.next) not in visited:
+                # Forward edge
+                dot.edge(f"node_{node_id}", f"node_{node_id + 1}", label="next")
+                # Backward edge
+                dot.edge(f"node_{node_id + 1}", f"node_{node_id}", label="prev", color="blue")
+
+            current = current.next
+            node_id += 1
+
+        return dot.pipe(format="svg", encoding="utf-8")
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DoublyListNode):
+            return False
+
+        if self._has_cycle() or other._has_cycle():
+            return False
+
+        return self.to_list() == other.to_list()