Merge branch 'DaleStudy:main' into main

Author: leokim0922

binary-tree-level-order-traversal/WhiteHyun.swift

@@ -0,0 +1,107 @@
+//  
+//  102. Binary Tree Level Order Traversal
+//  https://leetcode.com/problems/binary-tree-level-order-traversal/description/
+//  Dale-Study
+//  
+//  Created by WhiteHyun on 2024/06/12.
+//  
+
+// MARK: - Node
+
+private class Node<T> {
+  let element: T
+  var next: Node<T>?
+
+  init(element: T, next: Node<T>? = nil) {
+    self.element = element
+    self.next = next
+  }
+}
+
+// MARK: - Queue
+
+final class Queue<T> {
+  private var head: Node<T>?
+  private var tail: Node<T>?
+  private var count: Int = 0
+
+  var isEmpty: Bool {
+    count == 0
+  }
+
+  func enqueue(_ element: T) {
+    let newNode = Node(element: element)
+
+    if let tailNode = tail {
+      tailNode.next = newNode
+    } else {
+      head = newNode
+    }
+
+    tail = newNode
+    count += 1
+  }
+
+  func dequeue() -> T? {
+    guard let headNode = head
+    else {
+      return nil
+    }
+
+    let element = headNode.element
+    head = headNode.next
+
+    if head == nil {
+      tail = nil
+    }
+
+    count -= 1
+    return element
+  }
+
+  func peek() -> T? {
+    head?.element
+  }
+
+  func clear() {
+    head = nil
+    tail = nil
+    count = 0
+  }
+}
+
+// MARK: ExpressibleByArrayLiteral
+
+extension Queue: ExpressibleByArrayLiteral {
+  convenience init(arrayLiteral elements: T...) {
+    self.init()
+    for element in elements {
+      enqueue(element)
+    }
+  }
+}
+
+class Solution {
+  func levelOrder(_ root: TreeNode?) -> [[Int]] {
+    guard let root else { return [] }
+    var array: [[Int]] = []
+    let queue: Queue<(node: TreeNode, layer: Int)> = [(root, 0)]
+
+    while let (node, layer) = queue.dequeue() {
+      // array index 범위에 layer가 들어있지 않으면, 마지막 요소에 빈 배열 추가
+      if (array.indices ~= layer) == false {
+        array.append([])
+      }
+      array[layer].append(node.val)
+
+      if node.left != nil {
+        queue.enqueue((node.left!, layer + 1))
+      }
+      if node.right != nil {
+        queue.enqueue((node.right!, layer + 1))
+      }
+    }
+
+    return array
+  }
+}

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

@@ -0,0 +1,74 @@
+"""
+102. Binary Tree Level Order Traversal
+https://leetcode.com/problems/binary-tree-level-order-traversal/
+"""
+
+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
+
+    The problem is asking to return the node values at each level of the binary tree.
+    To solve this problem, we can use BFS algorithm with a queue.
+    We will traverse the tree level by level and store the node values at each level.
+
+    1. Initialize an empty list to store the output.
+    2. Initialize an empty queue.
+    3. Add the root node to the queue.
+    4. While the queue is not empty, do the following:
+        - Get the size of the queue to know the number of nodes at the current level.
+        - Initialize an empty list to store the node values at the current level.
+        - Traverse the nodes at the current level and add the node values to the list.
+        - If the node has left or right child, add them to the queue.
+        - Decrease the level size by 1.
+        - Add the list of node values at the current level to the output.
+    5. Return the output.
+
+Time complexity: O(N)
+    - We visit each node once
+
+Space complexity: O(N)
+    - The maximum number of nodes in the queue is the number of nodes at the last level
+    - The maximum number of nodes at the last level is N/2
+    - The output list stores the node values at each level which is N
+    - Thus, the space complexity is O(N)
+
+"""
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return
+        output = []
+        queue = []
+        queue.append(root)
+
+        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)
+
+                level_size -= 1
+
+            output.append(level_output)
+
+        return output

binary-tree-level-order-traversal/yolophg.js

@@ -0,0 +1,33 @@
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+
+var levelOrder = function (root) {
+  // if the root is null, return an empty array.
+  if (root === null) return [];
+
+  const result = [];
+  const queue = [root];
+
+  // while there are nodes in the queue,
+  while (queue.length > 0) {
+    const levelSize = queue.length;
+    const currentLevel = [];
+
+    // loop nodes in the current level.
+    for (let i = 0; i < levelSize; i++) {
+      // dequeue the front node.
+      const currentNode = queue.shift();
+      // add value to the current level array.
+      currentLevel.push(currentNode.val);
+      // enqueue left child if exists.
+      if (currentNode.left) queue.push(currentNode.left);
+      // enqueue right child if exists.
+      if (currentNode.right) queue.push(currentNode.right);
+    }
+
+    // add the current level array to the result.
+    result.push(currentLevel);
+  }
+
+  return result;
+};

combination-sum/evan.py

@@ -0,0 +1,42 @@
+from typing import List
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        def backtrack(remain, combination, candidateIndex):
+            if remain == 0:
+                # if we reach the target, add the combination to the result
+                result.append(list(combination))
+                return
+            elif remain < 0:
+                # if we exceed the target, no need to proceed
+                return
+
+            for i in range(candidateIndex, len(candidates)):
+                # add the number to the current combination
+                combination.append(candidates[i])
+                # continue the exploration with the current number
+                backtrack(remain - candidates[i], combination, i)
+                # backtrack by removing the number from the combination
+                combination.pop()
+
+        result = []
+        backtrack(target, [], 0)
+
+        return result
+
+
+# Time Complexity: O(N^(target / min(candidates)))
+# The time complexity depends on:
+# - N: The number of candidates (branching factor at each level).
+# - target: The target sum we need to achieve.
+# - min(candidates): The smallest element in candidates influences the maximum depth of the recursion tree.
+# In the worst case, we branch N times at each level, and the depth can be target / min(candidates).
+# Therefore, the overall time complexity is approximately O(N^(target / min(candidates))).
+
+# Space Complexity: O(target / min(candidates))
+# The space complexity is influenced by the maximum depth of the recursion tree:
+# - target: The target sum we need to achieve.
+# - min(candidates): The smallest element in candidates influences the maximum depth.
+# The recursion stack can go as deep as target / min(candidates), so the space complexity is O(target / min(candidates)).
+# Additionally, storing the results can take significant space, but it depends on the number of valid combinations found.

construct-binary-tree-from-preorder-and-inorder-traversal/evan.py

@@ -0,0 +1,37 @@
+from typing import List, Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        if not preorder or not inorder:
+            return None
+
+        root_val = preorder.pop(0)
+
+        root_inorder_index = inorder.index(root_val)
+
+        left_tree_inorder = inorder[:root_inorder_index]
+        right_tree_inorder = inorder[root_inorder_index + 1 :]
+
+        return TreeNode(
+            root_val,
+            self.buildTree(preorder, left_tree_inorder),
+            self.buildTree(preorder, right_tree_inorder),
+        )
+
+
+# Overall time complexity: O(N^2)
+# - Finding the root in the inorder list and splitting it takes O(N) time in each call.
+# - There are N nodes, so this operation is repeated N times.
+
+# Overall space complexity: O(N)
+# - The primary space usage is the recursion stack which goes as deep as the height of the tree.
+# - In the worst case (unbalanced tree), this can be O(N).
+# - In the best case (balanced tree), this is O(log N).

implement-trie-prefix-tree/evan.py

@@ -0,0 +1,37 @@
+class Trie:
+    def __init__(self):
+        self.children = {}
+        self.is_end_of_word = False
+
+    def insert(self, word: str) -> None:
+        node = self
+
+        for char in word:
+            if char not in node.children:
+                node.children[char] = Trie()
+
+            node = node.children[char]
+
+        node.is_end_of_word = True
+
+    def search(self, word: str) -> bool:
+        node = self
+
+        for char in word:
+            if char not in node.children:
+                return False
+
+            node = node.children[char]
+
+        return node.is_end_of_word
+
+    def startsWith(self, prefix: str) -> bool:
+        node = self
+
+        for char in prefix:
+            if char not in node.children:
+                return False
+
+            node = node.children[char]
+
+        return True

kth-smallest-element-in-a-bst/evan.py

@@ -0,0 +1,40 @@
+# Definition for a binary tree node.
+from typing import Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        result = []
+
+        def inorderTraverse(node: Optional[TreeNode]):
+            if node is None or len(result) >= k:
+                return
+
+            inorderTraverse(node.left)
+
+            if len(result) < k:
+                result.append(node.val)
+
+            inorderTraverse(node.right)
+
+        inorderTraverse(root)
+
+        return result[k - 1]
+
+
+# Time Complexity: O(N)
+# In the worst case, we need to visit all the nodes in the tree.
+# Thus, the time complexity is O(N), where N is the number of nodes in the tree.
+
+# Space Complexity: O(N)
+# The space complexity is determined by the recursion stack and the result list.
+# 1. Recursion stack: In the worst case (unbalanced tree), the recursion stack can go up to N levels deep, so the space complexity is O(N).
+#    In the best case (balanced tree), the recursion stack depth is log(N), so the space complexity is O(log N).
+# 2. Result list: The result list stores up to k elements, so the space complexity is O(k).