Run formatter

Author: sean424

binary-tree-level-order-traversal/bhyun-kim.py

@@ -5,13 +5,15 @@
 
 from typing import List, Optional
 
+
 # Definition for a binary tree node.
 class TreeNode:
     def __init__(self, val=0, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
 
+
 """
 Solution 
     Breadth First Search (BFS) using Queue
@@ -42,6 +44,8 @@ def __init__(self, val=0, left=None, right=None):
     - Thus, the space complexity is O(N)
 
 """
+
+
 class Solution:
     def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         if root is None:
@@ -50,18 +54,18 @@ def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         queue = []
         queue.append(root)
 
-        while(len(queue) > 0):
+        while len(queue) > 0:
             level_size = len(queue)
             level_output = []
-            
+
             while level_size > 0:
                 node = queue.pop(0)
                 level_output.append(node.val)
 
                 if node.left is not None:
                     queue.append(node.left)
                 if node.right is not None:
-                    queue.append(node.right) 
+                    queue.append(node.right)
 
                 level_size -= 1
 

lowest-common-ancestor-of-a-binary-search-tree/bhyun-kim.py

@@ -3,13 +3,15 @@
 https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
 """
 
+
 # Definition for a binary tree node.
 class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None
 
+
 """
 Solution:
     - If both p and q are greater than the root, the lowest common ancestor is in the right subtree.
@@ -22,15 +24,15 @@ def __init__(self, x):
     - Maximum depth of the recursion is the height of the tree
 """
 
+
 class Solution:
     def lowestCommonAncestor(
         self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
     ) -> "TreeNode":
-        
-        if p.val > root.val and q.val > root.val:    
+        if p.val > root.val and q.val > root.val:
             return self.lowestCommonAncestor(root.right, p, q)
-    
-        elif p.val < root.val and q.val < root.val:    
+
+        elif p.val < root.val and q.val < root.val:
             return self.lowestCommonAncestor(root.left, p, q)
         else:
-            return root
+            return root

remove-nth-node-from-end-of-list/bhyun-kim.py

@@ -6,11 +6,13 @@
 
 from typing import Optional
 
+
 class ListNode:
     def __init__(self, val=0, next=None):
         self.val = val
         self.next = next
 
+
 """
 Solution 1: 
 Two Pass Algorithm 1 
@@ -24,9 +26,9 @@ def __init__(self, val=0, next=None):
     - The new nodes are created to build the new list
 """
 
+
 class Solution1:
     def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
-    
         vals = []
 
         while head:
@@ -36,14 +38,13 @@ def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNod
         dummy_node = ListNode()
         tail = dummy_node
         idx_to_remove = len(vals) - n
-        vals = vals[:idx_to_remove] + vals[idx_to_remove+1:]
+        vals = vals[:idx_to_remove] + vals[idx_to_remove + 1 :]
 
         for v in vals:
             tail.next = ListNode(val=v)
             tail = tail.next
-        
+
         return dummy_node.next
-    
 
 
 """
@@ -61,20 +62,20 @@ def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNod
     - No extra space is required
 """
 
+
 class Solution2:
     def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
-    
         dummy = ListNode()
         dummy.next = head
         first = dummy
         second = dummy
 
-        for _ in range(n+1):
+        for _ in range(n + 1):
             first = first.next
 
         while first:
             first = first.next
-            second = second.next 
+            second = second.next
 
         second.next = second.next.next
 

reorder-list/bhyun-kim.py

@@ -5,11 +5,13 @@
 
 from typing import Optional
 
+
 class ListNode:
     def __init__(self, val=0, next=None):
         self.val = val
         self.next = next
 
+
 """
 Solution:
     To reorder the linked list, we can follow these steps:
@@ -52,7 +54,7 @@ def reorderList(self, head: Optional[ListNode]) -> None:
         """
         if not head or not head.next:
             return
-        
+
         slow, fast = head, head
         while fast and fast.next:
             slow = slow.next
@@ -70,4 +72,4 @@ def reorderList(self, head: Optional[ListNode]) -> None:
             tmp1, tmp2 = first.next, second.next
             first.next = second
             second.next = tmp1
-            first, second = tmp1, tmp2
+            first, second = tmp1, tmp2

validate-binary-search-tree/bhyun-kim.py

@@ -6,13 +6,14 @@
 """
 from typing import Optional
 
+
 class TreeNode:
     def __init__(self, val=0, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
 
-    
+
 """
 Solution1:
     Recursion
@@ -34,44 +35,39 @@ def __init__(self, val=0, left=None, right=None):
     - The function stores the range of values for each node
 """
 
+
 class Solution1:
     def isValidBST(self, root: Optional[TreeNode]) -> bool:
-        maximum = float('inf')
-        minimum = float('-inf')
-        return self.isValidSubTree(
-            root, maximum, minimum
-        )
+        maximum = float("inf")
+        minimum = float("-inf")
+        return self.isValidSubTree(root, maximum, minimum)
 
     def isValidSubTree(self, root, maximum, minimum):
-        if root.left is not None: 
-            if root.val <= root.left.val: 
+        if root.left is not None:
+            if root.val <= root.left.val:
                 return False
             if not minimum < root.left.val < maximum:
-                return False 
+                return False
 
-        if root.right is not None :
-            if root.val >= root.right.val: 
+        if root.right is not None:
+            if root.val >= root.right.val:
                 return False
             if not minimum < root.right.val < maximum:
-                return False 
+                return False
 
         if root.left is not None:
             l_max = min(maximum, root.val)
-            is_left_valid = self.isValidSubTree(
-                root.left, l_max, minimum
-                )
+            is_left_valid = self.isValidSubTree(root.left, l_max, minimum)
         else:
             is_left_valid = True
 
         if root.right is not None:
             r_min = max(minimum, root.val)
-            is_right_valid = self.isValidSubTree(
-                root.right, maximum, r_min 
-                )
+            is_right_valid = self.isValidSubTree(root.right, maximum, r_min)
         else:
             is_right_valid = True
-        
+
         if is_left_valid and is_right_valid:
             return True
-        else: 
-            return False
+        else:
+            return False