Add XOR Linked List implementation with doctests

Author: IneshAg

data_structures/linked_list/xor_linked_list.py

@@ -11,107 +11,68 @@
 [10, 20, 30]
 """
 
-# Note: This implementation simulates pointer behavior using Python's id()
-# and a dictionary lookup (_nodes). In languages like C, this would
-# be done with actual memory addresses and pointer arithmetic.
+# Note: 'from typing import Optional' is no longer needed
+# as we use the modern 'Node | None' syntax.
 
 
 class Node:
-    def __init__(self, value: int):
+    def __init__(self, value: int) -> None:
+        """Initializes a Node with a value and a null pointer."""
         self.value = value
         self.both: int = 0  # XOR of prev and next node ids
 
 
 class XORLinkedList:
-    def __init__(self):
-        # Use 'Node | None' instead of 'Optional[Node]' (per ruff UP045)
+    def __init__(self) -> None:
+        """Initializes an empty XOR Linked List."""
         self.head: Node | None = None
         self.tail: Node | None = None
         # id -> node map to simulate pointer references
-        # In a low-level language, we would just store/use the memory addresses.
         self._nodes: dict[int, Node] = {}
 
-    def _get_node(self, node_id: int) -> Node | None:
-        """Helper to retrieve a node by its simulated ID."""
-        return self._nodes.get(node_id)
-
-    def _get_id(self, node: Node | None) -> int:
-        """Helper to get the simulated ID (address) of a node."""
-        return id(node) if node else 0
-
     def _xor(self, a: Node | None, b: Node | None) -> int:
-        """Helper to XOR the IDs (addresses) of two nodes."""
-        # Use 'Node | None' instead of 'Optional[Node]' (per ruff UP045)
-        return self._get_id(a) ^ self._get_id(b)
+        """Helper function to get the XOR of two node IDs."""
+        return (id(a) if a else 0) ^ (id(b) if b else 0)
 
     def insert(self, value: int) -> None:
         """Inserts a value at the end of the list."""
         node = Node(value)
-        # Store the node in our simulated memory
         self._nodes[id(node)] = node
 
         if self.head is None:
-            # List is empty
-            self.head = node
-            self.tail = node
-            # node.both remains 0 (XOR of None and None)
+            # If the list is empty, head and tail are the new node
+            self.head = self.tail = node
         else:
-            # List is not empty, append to tail
-            # New node's 'both' points back to the old tail
-            node.both = self._get_id(self.tail)
-            
-            # Update the old tail's 'both'
-            # old_tail.both = (ID of node before old_tail) ^ (ID of new node)
-            # We can get (ID of node before old_tail) by doing:
-            # old_tail.both ^ (ID of next node, which was None/0)
-            # So, old_tail.both ^ 0 = old_tail.both
-            # new_tail.both = old_tail.both ^ self._get_id(node)
-            
-            # Simplified:
-            # self.tail.both was (ID of prev_node) ^ 0
-            # We need it to be (ID of prev_node) ^ (ID of new node)
-            # So we XOR it with the new node's ID.
-            if self.tail: # Type checker guard
-                self.tail.both = self.tail.both ^ self._get_id(node)
-            
-            # Update the tail pointer
+            # If the list is not empty, append to the tail
+            # The new node's pointer is just the ID of the old tail
+            node.both = id(self.tail)
+            if self.tail:  # Type checker guard
+                # The old tail's pointer must be updated to XOR
+                # its previous node ID with the new node's ID.
+                # self.tail.both was (prev_id ^ 0)
+                # self.tail.both becomes (prev_id ^ new_node_id)
+                self.tail.both ^= id(node)
             self.tail = node
 
     def to_list(self) -> list[int]:
-        """Converts the XOR linked list to a standard Python list (forward)."""
+        """Converts the XOR list to a standard Python list (forward traversal)."""
         result = []
+        prev_id = 0
         current = self.head
-        prev_id = 0  # ID of the virtual 'None' node before head
-        
         while current:
             result.append(current.value)
-            
-            # Get the ID of the next node
-            # current.both = (ID of prev_node) ^ (ID of next_node)
-            # So, (ID of next_node) = (ID of prev_node) ^ current.both
+            # Find next node's ID:
+            # current.both = prev_id ^ next_id
+            # so, next_id = prev_id ^ current.both
             next_id = prev_id ^ current.both
-            
-            # Move to the next node
-            prev_id = self._get_id(current)
-            current = self._get_node(next_id)
-            
+
+            # Move forward
+            prev_id = id(current)
+            current = self._nodes.get(next_id)
         return result
 
 
 if __name__ == "__main__":
     import doctest
 
-    doctest.testmod()
-
-    # Additional demonstration
-    xor_list = XORLinkedList()
-    xor_list.insert(10)
-    xor_list.insert(20)
-    xor_list.insert(30)
-    print(f"List contents: {xor_list.to_list()}") # Output: [10, 20, 30]
-    
-    # Verify head and tail
-    if xor_list.head:
-        print(f"Head value: {xor_list.head.value}") # Output: 10
-    if xor_list.tail:
-        print(f"Tail value: {xor_list.tail.value}") # Output: 30
+    doctest.testmod()