D. J.:

- Added the leetcode problem and solution for 23, 108, 148 and 427
- Added the implementation of the Quadtree data structure

Author: nobodyPerfecZ

README.md

@@ -39,6 +39,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/)
 - [21 Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
 - [22 Generate Parentheses](https://leetcode.com/problems/generate-parentheses/description/)
+- [23 Merge K Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/description/)
 - [25 Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/description/)
 - [26 Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/)
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
@@ -82,6 +83,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [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/)
+- [108 Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/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/)
@@ -101,6 +103,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [138 Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
 - [141 Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
 - [146 LRU Cache](https://leetcode.com/problems/lru-cache/description/)
+- [148 Sort List](https://leetcode.com/problems/sort-list/description/)
 - [149 Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/description/)
 - [150 Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/)
 - [151 Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/description/)
@@ -140,6 +143,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)
 - [392 Is Subsequence](https://leetcode.com/problems/is-subsequence/description/)
 - [399 Evaluate Division](https://leetcode.com/problems/evaluate-division/description/)
+- [427 Construct Quad Tree](https://leetcode.com/problems/construct-quad-tree/description/)
 - [433 Minimum Genetic Mutation](https://leetcode.com/problems/minimum-genetic-mutation/description/)
 - [452 Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
 - [530 Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)

awesome_python_leetcode/_108_convert_sorted_array_to_binary_search_tree.py

@@ -0,0 +1,20 @@
+from typing import List, Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        """
+        Given an integer array nums where the elements are sorted in ascending order,
+        convert it to a height-balanced binary search tree.
+        """
+        if not nums:
+            return None
+        mid = len(nums) // 2
+        node = TreeNode(val=nums[mid])
+        node.left = self.sortedArrayToBST(nums[:mid])
+        node.right = self.sortedArrayToBST(nums[mid + 1 :])
+        return node

awesome_python_leetcode/_148_sort_list.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from awesome_python_leetcode.list import ListNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def merge(self, left: Optional[ListNode], right: Optional[ListNode]):
+        dummy = ListNode(0)
+        head = dummy
+        while left and right:
+            if left.val < right.val:
+                head.next = left
+                left = left.next
+            else:
+                head.next = right
+                right = right.next
+            head = head.next
+        if left:
+            head.next = left
+        if right:
+            head.next = right
+        return dummy.next
+
+    def getMid(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        slow, fast = head, head.next
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        return slow
+
+    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        """
+        Given the head of a linked list, return the list after sorting it in
+        ascending order.
+        """
+        if not head or not head.next:
+            return head
+
+        # Split list into two halfs
+        left = head
+        right = self.getMid(head)
+        tmp = right.next
+        right.next = None
+        right = tmp
+
+        # Recursion
+        left = self.sortList(left)
+        right = self.sortList(right)
+        return self.merge(left, right)

awesome_python_leetcode/_23_merge_k_sorted_lists.py

@@ -0,0 +1,43 @@
+from typing import List, Optional
+
+from awesome_python_leetcode.list import ListNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def merge(self, left: Optional[ListNode], right: Optional[ListNode]):
+        dummy = ListNode(0)
+        head = dummy
+        while left and right:
+            if left.val < right.val:
+                head.next = left
+                left = left.next
+            else:
+                head.next = right
+                right = right.next
+            head = head.next
+        if left:
+            head.next = left
+        if right:
+            head.next = right
+        return dummy.next
+
+    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
+        """
+        You are given an array of k linked-lists lists, each linked-list is sorted in
+        ascending order.
+
+        Merge all the linked-lists into one sorted linked-list and return it.
+        """
+        if not lists:
+            return None
+        if len(lists) == 1:
+            return lists[0]
+        elif len(lists) == 2:
+            return self.merge(lists[0], lists[1])
+        else:
+            mid = len(lists) // 2
+            left = self.mergeKLists(lists[:mid])
+            right = self.mergeKLists(lists[mid:])
+            return self.merge(left, right)

awesome_python_leetcode/_427_construct_quad_tree.py

@@ -0,0 +1,59 @@
+from typing import List
+
+from awesome_python_leetcode.tree import QuadTreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def construct(self, grid: List[List[int]]) -> "QuadTreeNode":
+        """
+        Given a n * n matrix grid of 0's and 1's only. We want to represent grid with a
+        Quad-Tree.
+
+        Return the root of the Quad-Tree representing grid.
+
+        A Quad-Tree is a tree data structure in which each internal node has exactly
+        four children. Besides, each node has two attributes:
+        - val: True if the node represents a grid of 1's or False if the node represents
+        a grid of 0's. Notice that you can assign the val to True or False when isLeaf
+        is False, and both are accepted in the answer.
+        - isLeaf: True if the node is a leaf node on the tree or False if the node has
+        four children.
+        class Node {
+            public boolean val;
+            public boolean isLeaf;
+            public Node topLeft;
+            public Node topRight;
+            public Node bottomLeft;
+            public Node bottomRight;
+        }
+
+        We can construct a Quad-Tree from a two-dimensional area using the following
+        steps:
+        1. If the current grid has the same value (i.e all 1's or all 0's) set isLeaf
+        True and set val to the value of the grid and set the four children to Null
+        and stop.
+        2. If the current grid has different values, set isLeaf to False and set val to
+        any value and divide the current grid into four sub-grids as shown in the photo.
+        3. Recurse for each of the children with the proper sub-grid.
+        """
+
+        def dfs(n: int, row: int, col: int):
+            allSame = True
+            for i in range(n):
+                for j in range(n):
+                    if grid[row][col] != grid[row + i][col + j]:
+                        allSame = False
+                        break
+            if allSame:
+                return QuadTreeNode(grid[row][col], 1)
+
+            n = n // 2
+            topLeft = dfs(n, row, col)
+            topRight = dfs(n, row, col + n)
+            bottomLeft = dfs(n, row + n, col)
+            bottomRight = dfs(n, row + n, col + n)
+            return QuadTreeNode(0, 0, topLeft, topRight, bottomLeft, bottomRight)
+
+        return dfs(len(grid), 0, 0)

awesome_python_leetcode/tree.py

@@ -1,6 +1,85 @@
 from typing import List, Optional
 
 
+class QuadTreeNode:
+    """Quad tree node."""
+
+    def __init__(
+        self,
+        val: int = 0,
+        isLeaf: bool = False,
+        topLeft: Optional["QuadTreeNode"] = None,
+        topRight: Optional["QuadTreeNode"] = None,
+        bottomLeft: Optional["QuadTreeNode"] = None,
+        bottomRight: Optional["QuadTreeNode"] = None,
+    ):
+        self.val = val
+        self.isLeaf = isLeaf
+        self.topLeft = topLeft
+        self.topRight = topRight
+        self.bottomLeft = bottomLeft
+        self.bottomRight = bottomRight
+
+    def __eq__(self, other: "QuadTreeNode") -> bool:
+        if self is None and other is None:
+            return True
+        elif self is None:
+            return False
+        elif other is None:
+            return False
+        else:
+            return (
+                self.val == other.val
+                and self.isLeaf == other.isLeaf
+                and self.topLeft == other.topLeft
+                and self.topRight == other.topRight
+                and self.bottomLeft == other.bottomLeft
+                and self.bottomRight == other.bottomRight
+            )
+
+    @staticmethod
+    def build(levelorder: List[List[int]]) -> "QuadTreeNode":
+        """Build a binary tree from levelorder traversal."""
+        if not levelorder:
+            return None
+
+        node_data = levelorder.pop(0)
+        if node_data is None:
+            return None
+
+        isLeaf, val = node_data
+        head = QuadTreeNode(val, isLeaf)
+        queue = [(head, isLeaf)]
+
+        while queue and levelorder:
+            node, isLeaf = queue.pop(0)
+
+            node_data = levelorder.pop(0)
+            if node_data:
+                isLeaf, val = node_data
+                node.topLeft = QuadTreeNode(val, isLeaf)
+                queue.append((node.topLeft, isLeaf))
+
+            node_data = levelorder.pop(0)
+            if node_data:
+                isLeaf, val = node_data
+                node.topRight = QuadTreeNode(val, isLeaf)
+                queue.append((node.topRight, isLeaf))
+
+            node_data = levelorder.pop(0)
+            if node_data:
+                isLeaf, val = node_data
+                node.bottomLeft = QuadTreeNode(val, isLeaf)
+                queue.append((node.bottomLeft, isLeaf))
+
+            node_data = levelorder.pop(0)
+            if node_data:
+                isLeaf, val = node_data
+                node.bottomRight = QuadTreeNode(val, isLeaf)
+                queue.append((node.bottomRight, isLeaf))
+        return head
+
+
 class TreeNode:
     """Binary tree node."""
 

tests/test_108_convert_sorted_array_to_binary_search_tree.py

@@ -0,0 +1,22 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._108_convert_sorted_array_to_binary_search_tree import (
+    Solution,
+    TreeNode,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([-10, -3, 0, 5, 9], [0, -3, 9, -10, None, 5]),
+        ([1, 3], [3, 1]),
+    ],
+)
+def test_func(nums: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    expected = TreeNode.build(expected)
+    actual = Solution().sortedArrayToBST(nums)
+    assert actual == expected

tests/test_148_sort_list.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._148_sort_list import Solution, ListNode
+
+
+@pytest.mark.parametrize(
+    argnames=["head", "expected"],
+    argvalues=[
+        ([4, 2, 1, 3], [1, 2, 3, 4]),
+        ([-1, 5, 3, 4, 0], [-1, 0, 3, 4, 5]),
+        ([], []),
+    ],
+)
+def test_func(head: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    head = ListNode.build(head)
+    expected = ListNode.build(expected)
+    actual = Solution().sortList(head)
+    assert actual == expected

tests/test_23_merge_k_sorted_lists.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._23_merge_k_sorted_lists import Solution, ListNode
+
+
+@pytest.mark.parametrize(
+    argnames=["lists", "expected"],
+    argvalues=[
+        ([[1, 4, 5], [1, 3, 4], [2, 6]], [1, 1, 2, 3, 4, 4, 5, 6]),
+        ([], []),
+        ([[]], []),
+    ],
+)
+def test_func(lists: List[List[int]], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    lists = [ListNode.build(sublist) for sublist in lists]
+    expected = ListNode.build(expected)
+    actual = Solution().mergeKLists(lists)
+    assert actual == expected