D. J.:

- Changed the workflow file for automated format checking
- Changed the structure of the docstrings
- Added the leetcode problem and solution for 100, 101, 104, 105, 106, 112, 114, 117, 124, 129, 173, 222, 226, and 236

Author: nobodyPerfecZ

.github/workflows/check-format.yaml

@@ -24,7 +24,11 @@ jobs:
       - name: Install dependencies
         run: |
           pip install -r requirements.txt
-          pip install black
-      - name: Check Format with Black
+          pip install flake8
+      - name: Check Format with flake8
         run: |
-          black --check .
+          # stop the build if there are Python syntax errors or undefined names
+          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+          # exit-zero treats all errors as warnings. Black has 88 max-line-length
+          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics --ignore=E121,E123,E126,E203,E226,E24,E704,W503,W504
+

README.md

@@ -15,7 +15,7 @@
             <img src="https://img.shields.io/badge/tests-passed-brightgreen">
         </a>
         <a>
-            <img src="https://img.shields.io/badge/coverage-98%25-brightgreen">
+            <img src="https://img.shields.io/badge/coverage-97%25-brightgreen">
         </a>
     </h1>
 </div>
@@ -36,20 +36,34 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
+- [100 Same Tree](https://leetcode.com/problems/same-tree/description/)
+- [101 Symmetric Tree](https://leetcode.com/problems/symmetric-tree/description/)
+- [104 Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+- [105 Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/)
+- [106 Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/)
+- [112 Path Sum](https://leetcode.com/problems/path-sum/description/)
+- [114 Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/)
+- [117 Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/description/)
 - [121 Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 - [122 Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
+- [124 Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/description/)
 - [125 Valid Palindrome](https://leetcode.com/problems/valid-palindrome/description/)
 - [128 Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/description/)
+- [129 Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/description/)
 - [150 Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/description/)
 - [169 Majority Element](https://leetcode.com/problems/majority-element/description/)
+- [173 Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/)
 - [189 Rotate Array](https://leetcode.com/problems/rotate-array/description/)
 - [202 Happy Number](https://leetcode.com/problems/happy-number/description/)
 - [205 Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/description/)
 - [219 Contains Duplicates II](https://leetcode.com/problems/contains-duplicate-ii/description/)
+- [222 Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/description/)
 - [224 Basic Calculator](https://leetcode.com/problems/basic-calculator/description/)
+- [226 Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/description/)
 - [227 Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/description/)
 - [228 Summary Ranges](https://leetcode.com/problems/summary-ranges/description/)
+- [236 Lowest Common Ancestor of a Binary Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/description/)
 - [242 Valid Anagram](https://leetcode.com/problems/valid-anagram/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)

awesome_python_leetcode/_100_same_tree.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        """
+        Given the roots of two binary trees p and q, write a function to check if they
+        are the same or not.
+
+        Two binary trees are considered the same if they are structurally identical, and
+        the nodes have the same value.
+        """
+        if p is None and q is None:
+            return True
+        elif p is None:
+            return False
+        elif q is None:
+            return False
+        else:
+            return (
+                p.val == q.val
+                and self.isSameTree(p.left, q.left)
+                and self.isSameTree(p.right, q.right)
+            )

awesome_python_leetcode/_101_symmetric_tree.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
+        """
+        Given the root of a binary tree, check whether it is a mirror of itself
+        (i.e., symmetric around its center).
+        """
+
+        def _is_symmetric(left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
+            if left is None and right is None:
+                return True
+            elif left is None:
+                return False
+            elif right is None:
+                return False
+            else:
+                return (
+                    left.val == right.val
+                    and _is_symmetric(left.left, right.right)
+                    and _is_symmetric(left.right, right.left)
+                )
+
+        if root is None:
+            return True
+        return _is_symmetric(root.left, root.right)

awesome_python_leetcode/_104_maximum_depth_of_binary_tree.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        """
+        Given the root of a binary tree, return its maximum depth.
+
+        A binary tree's maximum depth is the number of nodes along the longest path
+        from the root node down to the farthest leaf node.
+        """
+        if root is None:
+            return 0
+        else:
+            return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

awesome_python_leetcode/_105_construct_binary_tree_from_preorder_and_inorder_traversal.py

@@ -0,0 +1,24 @@
+from typing import List, Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        """
+        Given two integer arrays preorder and inorder where preorder is the preorder
+        traversal of a binary tree and inorder is the inorder traversal of the same
+        tree, construct and return the binary tree.
+        """
+        if not preorder or not inorder:
+            return None
+        root = preorder[0]
+        mid = inorder.index(root)
+        return TreeNode(
+            val=root,
+            left=self.buildTree(preorder[1 : mid + 1], inorder[:mid]),
+            right=self.buildTree(preorder[mid + 1 :], inorder[mid + 1 :]),
+        )

awesome_python_leetcode/_106_construct_binary_tree_from_inorder_and_postorder_traversal.py

@@ -0,0 +1,25 @@
+from typing import List, Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
+        """
+        Given two integer arrays inorder and postorder where inorder is the inorder
+        traversal of a binary tree and postorder is the postorder traversal of the same
+        tree, construct and return the binary tree.
+        """
+        if not inorder or not postorder:
+            return None
+        else:
+            root = postorder.pop(-1)
+            mid = inorder.index(root)
+            return TreeNode(
+                val=root,
+                right=self.buildTree(inorder[mid + 1 :], postorder),
+                left=self.buildTree(inorder[:mid], postorder),
+            )

awesome_python_leetcode/_112_path_sum.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
+        """
+        Given the root of a binary tree and an integer targetSum, return true if the
+        tree has a root-to-leaf path such that adding up all the values along the path
+        equals targetSum.
+
+        A leaf is a node with no children.
+        """
+        if root is None:
+            return False
+        elif root.left is None and root.right is None:
+            return targetSum - root.val == 0
+        elif root.left is None:
+            return self.hasPathSum(root.right, targetSum - root.val)
+        elif root.right is None:
+            return self.hasPathSum(root.left, targetSum - root.val)
+        else:
+            return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(
+                root.right, targetSum - root.val
+            )

awesome_python_leetcode/_114_flatten_binary_tree_to_linked_list.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def flatten(self, root: Optional[TreeNode]):
+        """
+        Given the root of a binary tree, flatten the tree into a "linked list":
+        - The "linked list" should use the same TreeNode class where the right child
+        pointer points to the next node in the list and the left child pointer is always
+        null.
+        - The "linked list" should be in the same order as a pre-order traversal of the
+        binary tree.
+        - Do not return anything, modify root in-place instead.
+        """
+
+        def dfs(root: Optional[TreeNode]) -> Optional[TreeNode]:
+            if not root:
+                return None
+
+            left = dfs(root.left)
+            right = dfs(root.right)
+
+            if root.left:
+                left.right = root.right
+                root.right = root.left
+                root.left = None
+
+            last = right or left or root
+            return last
+
+        dfs(root)

awesome_python_leetcode/_117_populating_next_right_pointers_in_each_node_II.py

@@ -0,0 +1,36 @@
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def connect(self, root: TreeNode) -> TreeNode:
+        """
+        Populate each next pointer to point to its next right node. If there is no next
+        right node, the next pointer should be set to NULL.
+
+        Initially, all next pointers are set to NULL.
+        """
+        if root is None:
+            return None
+
+        parents = [root]
+        while parents:
+            # Connect nodes together
+            for i in range(len(parents) - 1):
+                parents[i].next = parents[i + 1]
+
+            # Build next layer
+            children = []
+            for parent in parents:
+                if parent.left is not None and parent.right is not None:
+                    children.append(parent.left)
+                    children.append(parent.right)
+                elif parent.left is not None:
+                    children.append(parent.left)
+                elif parent.right is not None:
+                    children.append(parent.right)
+
+            # Update layer
+            parents = children
+        return root