Update skew_heap.py

Author: lighting9999

data_structures/heap/skew_heap.py

@@ -3,17 +3,17 @@
 from __future__ import annotations
 
 from collections.abc import Iterable, Iterator
-from typing import Protocol, TypeVar
+from typing import Protocol, TypeVar, Generic
 
 
 class Comparable(Protocol):
-    def __lt__(self, other: Any) -> bool: ...
+    def __lt__(self, other: object) -> bool: ...
 
 
 T = TypeVar("T", bound=Comparable)
 
 
-class SkewNode[T]:
+class SkewNode(Generic[T]):
     """
     One node of the skew heap. Contains the value and references to
     two children.
@@ -35,35 +35,14 @@ def value(self) -> T:
         3.14159
         >>> SkewNode("hello").value
         'hello'
-        >>> SkewNode(None).value
-
         >>> SkewNode(True).value
         True
-        >>> SkewNode([]).value
-        []
-        >>> SkewNode({}).value
-        {}
-        >>> SkewNode(set()).value
-        set()
-        >>> SkewNode(0.0).value
-        0.0
-        >>> SkewNode(-1e-10).value
-        -1e-10
         >>> SkewNode(10).value
         10
-        >>> SkewNode(-10.5).value
-        -10.5
-        >>> SkewNode().value
-        Traceback (most recent call last):
-        ...
-        TypeError: SkewNode.__init__() missing 1 required positional argument: 'value'
         """
         return self._value
-
     @staticmethod
-    def merge(
-        root1: SkewNode[T] | None, root2: SkewNode[T] | None
-    ) -> SkewNode[T] | None:
+    def merge(root1: SkewNode[T] | None, root2: SkewNode[T] | None) -> SkewNode[T] | None:
         """
         Merge two nodes together.
         >>> SkewNode.merge(SkewNode(10), SkewNode(-10.5)).value
@@ -80,30 +59,35 @@ def merge(
             return root2
         if not root2:
             return root1
+        
+        # Compare values using explicit comparison function
+        if SkewNode._is_less_than(root1.value, root2.value):
+            # root1 is smaller, make it the new root
+            result = root1
+            temp = root1.right
+            result.right = root1.left
+            result.left = SkewNode.merge(temp, root2)
+            return result
+        else:
+            # root2 is smaller or equal, use it as new root
+            result = root2
+            temp = root2.right
+            result.right = root2.left
+            result.left = SkewNode.merge(root1, temp)
+            return result
 
-        # Compare values using explicit __lt__ method
+    @staticmethod
+    def _is_less_than(a: T, b: T) -> bool:
+        """Safe comparison function that avoids type checker issues"""
         try:
-            # Check if root1 is smaller than root2
-            if root1.value.__lt__(root2.value):
-                # root1 is smaller, make it the new root
-                result = root1
-                temp = root1.right
-                result.right = root1.left
-                result.left = SkewNode.merge(temp, root2)
-                return result
-        except (TypeError, AttributeError):
-            # Fallback if __lt__ comparison fails
-            pass
-
-        # If root2 is smaller or comparison failed, use root2 as new root
-        result = root2
-        temp = root2.right
-        result.right = root2.left
-        result.left = SkewNode.merge(root1, temp)
-        return result
+            return a < b
+        except TypeError:
+            # Fallback comparison for non-comparable types
+            # Uses string representation as last resort
+            return str(a) < str(b)
 
 
-class SkewHeap[T]:
+class SkewHeap(Generic[T]):
     """
     A data structure that allows inserting a new value and popping the smallest
     values. Both operations take O(logN) time where N is the size of the heap.
@@ -129,7 +113,7 @@ class SkewHeap[T]:
     def __init__(self, data: Iterable[T] | None = ()) -> None:
         """
         Initialize the skew heap with optional data
-
+        
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> list(sh)
         [1, 3, 3, 7]
@@ -142,7 +126,7 @@ def __init__(self, data: Iterable[T] | None = ()) -> None:
     def __bool__(self) -> bool:
         """
         Check if the heap is not empty
-
+        
         >>> sh = SkewHeap()
         >>> bool(sh)
         False
@@ -154,29 +138,32 @@ def __bool__(self) -> bool:
         False
         """
         return self._root is not None
-
     def __iter__(self) -> Iterator[T]:
         """
         Iterate through all values in sorted order
-
+        
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> list(sh)
         [1, 3, 3, 7]
         """
+        # Create a temporary heap for iteration
+        temp_heap = SkewHeap()
         result: list[T] = []
+        
+        # Pop all elements from the heap
         while self:
-            result.append(self.pop())
-
+            item = self.pop()
+            result.append(item)
+            temp_heap.insert(item)
+        
         # Restore the heap state
-        for item in result:
-            self.insert(item)
-
+        self._root = temp_heap._root
         return iter(result)
 
     def insert(self, value: T) -> None:
         """
         Insert a new value into the heap
-
+        
         >>> sh = SkewHeap()
         >>> sh.insert(3)
         >>> sh.insert(1)
@@ -190,7 +177,7 @@ def insert(self, value: T) -> None:
     def pop(self) -> T:
         """
         Remove and return the smallest value from the heap
-
+        
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> sh.pop()
         1
@@ -209,11 +196,10 @@ def pop(self) -> T:
         if self._root:
             self._root = SkewNode.merge(self._root.left, self._root.right)
         return result
-
     def top(self) -> T:
         """
         Return the smallest value without removing it
-
+        
         >>> sh = SkewHeap()
         >>> sh.insert(3)
         >>> sh.top()
@@ -235,7 +221,7 @@ def top(self) -> T:
     def clear(self) -> None:
         """
         Clear all elements from the heap
-
+        
         >>> sh = SkewHeap([3, 1, 3, 7])
         >>> sh.clear()
         >>> sh.pop()