Merge branch 'DaleStudy:main' into main

Author: wogha95

binary-tree-level-order-traversal/EGON.py

@@ -0,0 +1,108 @@
+from collections import deque
+from typing import Optional, List
+from unittest import TestCase, main
+
+
+# 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
+
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        return self.solve_dfs(root)
+
+    """
+    Runtime: 0 ms (Beats 100.00%)
+    Time Complexity: O(n)
+        > 각 node를 bfs 방식으로 한 번 씩 조회하므로 O(n)
+
+    Memory: 17.42 (Beats 11.96%)
+    Space Complexity: O(n)
+        > 최악의 경우, deque에 최대 node의 갯수만큼 저장될 수 있으므로 O(n), upper bound
+    """
+    def solve_bfs(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+
+        dq = deque([root])
+        result = []
+        while dq:
+            tmp_result = []
+            for _ in range(len(dq)):
+                curr = dq.popleft()
+                tmp_result.append(curr.val)
+
+                if curr.left:
+                    dq.append(curr.left)
+                if curr.right:
+                    dq.append(curr.right)
+
+            result.append(tmp_result)
+
+        return result
+
+    """
+    Runtime: 1 ms (Beats 38.71%)
+    Time Complexity: O(n)
+        > 각 node를 dfs 방식으로 한 번 씩 조회하므로 O(n)
+
+    Memory: 17.49 (Beats 11.96%)
+    Space Complexity: O(1)
+        > 최악의 경우, list에 최대 node의 갯수만큼 저장될 수 있으므로 O(n), upper bound
+    """
+    def solve_dfs(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+
+        def dfs(node: TreeNode, depth: int):
+            if len(result) <= depth:
+                result.append([node.val])
+            else:
+                result[depth].append(node.val)
+
+            if node.left:
+                dfs(node.left, depth + 1)
+            if node.right:
+                dfs(node.right, depth + 1)
+
+        result = []
+        dfs(root, 0)
+
+        return result
+
+
+class _LeetCodeTestCases(TestCase):
+
+    def test_1(self):
+        root = TreeNode(3)
+        node1 = TreeNode(9)
+        node2 = TreeNode(20)
+        node3 = TreeNode(15)
+        node4 = TreeNode(7)
+        root.left = node1
+        root.right = node2
+        node2.left = node3
+        node2.right = node4
+        output = [[3], [9, 20], [15, 7]]
+        self.assertEqual(Solution.levelOrder(Solution(), root), output)
+
+    def test_2(self):
+        root = TreeNode(1)
+        node1 = TreeNode(2)
+        node2 = TreeNode(3)
+        node3 = TreeNode(4)
+        node4 = TreeNode(5)
+        root.left = node1
+        root.right = node2
+        node1.left = node3
+        node2.left = node4
+        output = [[1], [2, 3], [4, 5]]
+        self.assertEqual(Solution.levelOrder(Solution(), root), output)
+
+
+if __name__ == '__main__':
+    main()

binary-tree-level-order-traversal/HC-kang.ts

@@ -0,0 +1,57 @@
+// class TreeNode {
+//   val: number;
+//   left: TreeNode | null;
+//   right: TreeNode | null;
+//   constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+//     this.val = val === undefined ? 0 : val;
+//     this.left = left === undefined ? null : left;
+//     this.right = right === undefined ? null : right;
+//   }
+// }
+
+/**
+ * https://leetcode.com/problems/binary-tree-level-order-traversal
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function levelOrder(root: TreeNode | null): number[][] {
+  const result: number[][] = [];
+  function dfs(node: TreeNode | null, level: number) {
+    if (!node) return;
+    if (!result[level]) result[level] = [];
+    result[level].push(node.val);
+    dfs(node.left, level + 1);
+    dfs(node.right, level + 1);
+  }
+  dfs(root, 0);
+  return result;
+}
+
+/**
+ * bfs
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function levelOrder(root: TreeNode | null): number[][] {
+  const result: number[][] = [];
+  if (!root) return result;
+
+  const queue: TreeNode[] = [root];
+  let start = 0;
+
+  while (queue[start]) {
+    const levelSize = queue.length - start;
+    const currentLevel: number[] = [];
+
+    for (let i = 0; i < levelSize; i++) {
+      const node = queue[start++];
+      currentLevel.push(node.val);
+      if (node.left) queue.push(node.left);
+      if (node.right) queue.push(node.right);
+    }
+
+    result.push(currentLevel);
+  }
+
+  return result;
+}

binary-tree-level-order-traversal/TonyKim9401.java

@@ -0,0 +1,26 @@
+// TC: O(n)
+// need to visit all nodes
+// SC: O(n)
+// normally O(log n) required however, O(n) in the worst case
+class Solution {
+    private List<List<Integer>> output = new ArrayList<>();
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        dfs(0, root);
+        return output;
+    }
+
+    private void dfs(int level, TreeNode node) {
+        if (node == null) return;
+
+        if (output.size() == level) {
+            List<Integer> inside = new ArrayList<>();
+            inside.add(node.val);
+            output.add(inside);
+        } else {
+            output.get(level).add(node.val);
+        }
+        level += 1;
+        dfs(level, node.left);
+        dfs(level, node.right);
+    }
+}

binary-tree-level-order-traversal/flynn.go

@@ -0,0 +1,52 @@
+/*
+풀이
+- queue 자료구조를 사용하여 풀이합니다
+Big O
+- N: 노드의 개수
+- Time complexity: O(N)
+  - 모든 노드를 조회합니다
+- Space complexity: O(N)
+  - 반환 결과값인 2차원 배열 levels -> O(N)
+  - queue -> O(3/4 * N) = O(N)
+    - 한 층이 가질 수 있는 최대 노드 개수는 약 N / 2
+	- queue의 크기가 가장 클 때는 두 층의 노드를 가지고 있으므로 N / 2 + (N / 2) / 2 개의 노드를 갖게 됨
+  - level -> O(N/2) = O(N)
+    - - 한 층이 가질 수 있는 최대 노드 개수는 약 N / 2
+*/
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+ func levelOrder(root *TreeNode) [][]int {
+	levels := make([][]int, 0)
+
+	if root == nil {
+		return levels
+	}
+
+	queue := make([]*TreeNode, 0)
+	queue = append(queue, root)
+	for len(queue) > 0 {
+		k := len(queue)
+		level := make([]int, k)
+		for i := 0; i < k; i++ {
+			node := queue[i]
+			level[i] = node.Val
+			if node.Left != nil {
+				queue = append(queue, node.Left)
+			}
+			if node.Right != nil {
+				queue = append(queue, node.Right)
+			}
+		}
+		queue = queue[k:]
+		levels = append(levels, level)
+	}
+
+	return levels
+}

binary-tree-level-order-traversal/jdalma.kt

@@ -0,0 +1,63 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `binary-tree-level-order-traversal` {
+
+    fun levelOrder(root: TreeNode?): List<List<Int>> {
+        return if (root == null) emptyList()
+        else usingDFS(root)
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingBFS(root: TreeNode): List<List<Int>> {
+        val queue = ArrayDeque<TreeNode>().apply {
+            this.add(root)
+        }
+
+        val result = mutableListOf<List<Int>>()
+        while (queue.isNotEmpty()) {
+            val values = mutableListOf<Int>()
+            repeat(queue.size) {
+                val node = queue.removeFirst()
+                values.add(node.`val`)
+                node.left?.also { queue.add(it) }
+                node.right?.also { queue.add(it) }
+            }
+            result.add(values)
+        }
+
+        return result
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDFS(root: TreeNode): List<List<Int>> {
+
+        fun dfs(node: TreeNode, result: MutableList<MutableList<Int>>, depth: Int) {
+            if (depth >= result.size) {
+                result.add(mutableListOf())
+            }
+            result[depth].add(node.`val`)
+            node.left?.also { dfs(it, result, depth + 1) }
+            node.right?.also { dfs(it, result, depth + 1) }
+        }
+
+        return mutableListOf<MutableList<Int>>().apply {
+            dfs(root, this, 0)
+        }
+    }
+
+    @Test
+    fun `트리 노드를 깊이 별로 반환한다`() {
+        levelOrder(TreeNode.of(3,9,20,null,null,15,7)) shouldBe listOf(
+            listOf(3),
+            listOf(9,20),
+            listOf(15,7)
+        )
+    }
+}

binary-tree-level-order-traversal/kayden.py

@@ -0,0 +1,19 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(N)
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def traverse(node, level):
+            if not node:
+                return
+
+            if len(result) <= level:
+                result.append([])
+
+            result[level].append(node.val)
+
+            traverse(node.left, level + 1)
+            traverse(node.right, level + 1)
+
+        result = []
+        traverse(root, 0)
+        return result

binary-tree-level-order-traversal/mangodm-web.py

@@ -0,0 +1,42 @@
+from collections import deque
+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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        """
+        - Idea: 너비 우선 탐색(BFS)를 이용하여 이진 트리를 단계 별로 순회한다.
+        - Time Complexity: O(n). n은 트리의 노드 수.
+            모든 노드를 한번씩 방문하므로 O(n) 시간이 걸린다.
+        - Space Complexity: O(n). n은 트리의 노드 수.
+            가장 아래 단계에 있는 노드를 저장할 때 가장 많은 메모리를 사용하고, 이는 n에 비례하기 때문에 O(n) 만큼의 메모리가 필요하다.
+        """
+        if not root:
+            return []
+
+        result = []
+        queue = deque()
+        queue.append(root)
+
+        while queue:
+            level = []
+
+            for i in range(len(queue)):
+                node = queue.popleft()
+                level.append(node.val)
+
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+
+            result.append(level)
+
+        return result