minor refactor

Author: lilyhe123

src/008.py

@@ -28,22 +28,7 @@
 
 """
 
-
-class TreeNode:
-    def __init__(self, val: int, left: object = None, right: object = None):
-        self.val = val
-        self.left = left
-        self.right = right
-
-    def print(self):
-        print(self.val)
-
-    def print_inorder(self):
-        if self.left:
-            self.print_inorder(self.left)
-        self.print()
-        if self.right:
-            self.print_inorder(self.right)
+from ds.classes import TreeNode
 
 
 def getUnivalTreeNum(node: object) -> int:
@@ -84,3 +69,7 @@ def test_8():
         ),
     )
     assert getUnivalTreeNum(root) == 5
+
+
+if __name__ == "__main__":
+    test_8()

src/020.py

@@ -35,21 +35,7 @@
    use next pointer to point to its previous.
 """
 
-
-class LinkedNode:
-    def __init__(self, val):
-        self.val = val
-        self.next = None
-
-    def print(self):
-        node = self
-        s = ""
-        while node:
-            s += str(node.val)
-            if node.next:
-                s += "->"
-            node = node.next
-        print(s)
+from ds.classes import LinkedNode
 
 
 def revert(head):
@@ -62,20 +48,6 @@ def revert(head):
     return pre
 
 
-def createLinkedList(nums):
-    head, pre = None, None
-
-    for num in nums:
-        node = LinkedNode(num)
-        if not head:
-            head = node
-            pre = node
-        else:
-            pre.next = node
-        pre = node
-    return head
-
-
 def getIntersectingNode(head1, head2):
     # edge case: if either list is None, there is no intersection
     if not head1 or not head2:
@@ -97,8 +69,8 @@ def getIntersectingNode(head1, head2):
 
 
 def runOneTest20(array_one, array_two, expected):
-    head1 = createLinkedList(array_one)
-    head2 = createLinkedList(array_two)
+    head1 = LinkedNode.createLinkedList(array_one)
+    head2 = LinkedNode.createLinkedList(array_two)
     if not expected:
         assert getIntersectingNode(head1, head2) is None
     else:
@@ -121,3 +93,7 @@ def test_20():
     array_one = [1, 15, 20, 16, 10]
     array_two = [1, 15, 20, 16, 10]
     runOneTest20(array_one, array_two, 1)
+
+
+if __name__ == "__main__":
+    test_20()

src/067.py

@@ -50,11 +50,11 @@
 
 """
 
-from ds.classes import DoubleLinkedList, ListNode
+from ds.classes import DoubleLinkedList, DoubleLinkedNode
 
 
 # !! class inheritance
-class LFUNode(ListNode):
+class LFUNode(DoubleLinkedNode):
     def __init__(self, key, value):
         super().__init__(key, value)
         self.freq = 1

src/ds/classes.py

@@ -1,4 +1,34 @@
-class ListNode:
+class LinkedNode:
+    def __init__(self, val):
+        self.val = val
+        self.next = None
+
+    def print(self):
+        node = self
+        s = ""
+        while node:
+            s += str(node.val)
+            if node.next:
+                s += "->"
+            node = node.next
+        print(s)
+
+    @staticmethod
+    def createLinkedList(nums):
+        head, pre = None, None
+
+        for num in nums:
+            node = LinkedNode(num)
+            if not head:
+                head = node
+                pre = node
+            else:
+                pre.next = node
+            pre = node
+        return head
+
+
+class DoubleLinkedNode:
     def __init__(self, key, value):
         self.key = key
         self.value = value
@@ -11,8 +41,8 @@ def __init__(self, key, value):
 # !! use dummy head and tail to simplify code
 class DoubleLinkedList:
     def __init__(self):
-        self.head = ListNode(None, None)
-        self.tail = ListNode(None, None)
+        self.head = DoubleLinkedNode(None, None)
+        self.tail = DoubleLinkedNode(None, None)
         self.head.next = self.tail
         self.tail.pre = self.head
 
@@ -27,8 +57,8 @@ def addToHead(self, node):
         self.head.next = node
         node.list = self
 
-    def add(self, key, value) -> ListNode:
-        node = ListNode(key, value)
+    def add(self, key, value) -> DoubleLinkedNode:
+        node = DoubleLinkedNode(key, value)
         self.addToHead(node)
         return node
 
@@ -43,15 +73,15 @@ def moveToHead(self, node) -> None:
         self.removeNode(node)
         self.addToHead(node)
 
-    def removeHead(self) -> ListNode:
+    def removeHead(self) -> DoubleLinkedNode:
         if self.isEmpty():
             return
         node = self.head.next
         self.head.next = node.next
         node.next.pre = self.head
         return node
 
-    def removeTail(self) -> ListNode:
+    def removeTail(self) -> DoubleLinkedNode:
         if self.isEmpty():
             return
         node = self.tail.pre