Merge branch 'DaleStudy:main' into main

Author: jdy8739

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

@@ -0,0 +1,46 @@
+"""
+Constraints:
+- The number of nodes in the tree is in the range [0, 2000].
+- -1000 <= Node.val <= 1000
+
+Time Complexity: O(n)
+- 각 노드를 한 번씩만 방문함
+
+Space Complexity: O(n)
+- 결과 리스트는 모든 노드의 값을 저장함
+
+풀이방법:
+1. queue와 BFS를 활용하여 레벨 순서로 노드를 순회
+2. 각 레벨의 노드들을 별도의 리스트로 모아서 결과에 추가
+3. 각 노드를 처리할 때 그 노드의 자식들을 큐에 추가하여 다음 레벨로 넘어감
+"""
+# 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]]:
+        if not root:
+            return []
+
+        result = []
+        queue = deque([root])
+
+        while queue:
+            level_size = len(queue)
+            current_level = []
+
+            for _ in range(level_size):
+                node = queue.popleft()
+                current_level.append(node.val)
+
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            
+            result.append(current_level)
+
+        return result

binary-tree-level-order-traversal/Yjason-K.ts

@@ -0,0 +1,52 @@
+/**
+ * 이진 트리 노드의 정의입니다.
+ * 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);
+ *     }
+ * }
+ */
+
+/**
+ * 이진트리 깊이별 노드 값들을 배열로 저장하는 함수.
+ * 
+ * @param {TreeNode | null} root - 이진 트리의 루트 노드
+ * @returns {number[][]} - 각 레벨별 노드 값들이 담긴 2차원 배열 반환
+ * 
+ * 시간 복잡도: O(n) 
+ *   - 모든 노드를 한 번씩 방문
+ * 공간 복잡도: O(n) 
+ *   - 재귀 호출 스택 및 결과 배열 사용
+ */
+function levelOrder(root: TreeNode | null): number[][] {
+    // idx -> 각 깊이별 노드 값들을 저장
+    const result: number[][] = [];
+
+    const dfs = (node: TreeNode | null, depth: number): void => {
+        // 노드가 null이면 재귀 종료
+        if (node === null) return;
+        
+        // 현재 depth를 처음 방문되는 경우, 결과 배열에 새로운 depth 배열을 추가
+        if (result.length === depth) {
+            result.push([]);
+        }
+        
+        // 현재 노드의 값을 해당 레벨 배열에 추가
+        result[depth].push(node.val);
+        
+        // 왼쪽 자식 노드를 방문 (depth 1 증가시킴)
+        dfs(node.left, depth + 1);
+        // 오른쪽 자식 노드를 방문 (depth 1 증가시킴)
+        dfs(node.right, depth + 1);
+    }
+
+    // depth 0부터 탐색 시작
+    dfs(root, 0);
+    return result;
+};
+

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

@@ -0,0 +1,82 @@
+'''
+# Leetcode 102. Binary Tree Level Order Traversal
+
+do level order traversal
+
+```
+💡  why use BFS?:
+BFS is the recommended approach, because it aligns with the problem's concept of processing the binary tree level by level and avoids issues related to recursion depth, making the solution both cleaner and more reliable.  
+
+- DFS doesn't naturally support level-by-level traversal, so we need an extra variable like "dep" (depth).
+- BFS is naturally designed for level traversal, making it a better fit for the problem.
+- additionally, BFS can avoid potential stack overflow.
+```
+
+## A. BFS
+
+### re-structuring the tree into a queue:
+- use the queue for traverse the binary tree by level.
+
+### level traversal:
+- pop the leftmost node
+- append the node's value to current level's array
+- enqueue the left and right children to queue
+- can only process nodes at the current level, because of level_size.
+
+## B. DFS
+- travase with a dep parameter => dp(node, dep)
+- store the traversal result
+'''
+class Solution:
+    '''
+    A. BFS
+    TC: O(n)
+    SC: O(n)
+    '''
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+        
+        result = [] # SC: O(n)
+        queue = deque([root]) # SC: O(n)
+
+        while queue: # TC: O(n)
+            level_size = len(queue)
+            level = []
+
+            for _ in range(level_size):
+                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
+
+    '''
+    B. DFS
+    TC: O(n)
+    SC: O(n)
+    '''
+    def levelOrderDP(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = [] # SC: O(n)
+
+        def dp(node, dep):
+            if node is None:
+                return
+
+            if len(result) <= dep:
+                result.append([])
+
+            result[dep].append(node.val)
+            
+            dp(node.left, dep + 1)
+            dp(node.right, dep + 1)
+
+        dp(root, 0) # TC: O(n) call stack
+
+        return result

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

@@ -0,0 +1,42 @@
+/*
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+  - 재귀 호출 함수의 파라미터 root, depth, ans
+*/
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> ans = new ArrayList<>();
+
+        dfs(root, 0, ans);
+
+        return ans;
+    }
+
+    private void dfs(TreeNode root, int depth, List<List<Integer>> ans) {
+        if (root == null) return;
+
+        if (ans.size() == depth) {
+            ans.add(new ArrayList<>());
+        }
+        ans.get(depth).add(root.val);
+
+        dfs(root.left, depth + 1, ans);
+        dfs(root.right, depth + 1, ans);
+    }
+}

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

@@ -0,0 +1,67 @@
+// n: number of nodes
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+class _Queue {
+  constructor() {
+    this.q = [];
+    this.front = 0;
+    this.rear = 0;
+  }
+
+  push(value) {
+    this.q.push(value);
+    this.rear++;
+  }
+
+  shift() {
+    const rv = this.q[this.front];
+    delete this.q[this.front++];
+    return rv;
+  }
+
+  isEmpty() {
+    return this.front === this.rear;
+  }
+}
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var levelOrder = function (root) {
+  const answer = [];
+  const q = new _Queue();
+
+  if (root) {
+    q.push([root, 0]);
+  }
+
+  while (!q.isEmpty()) {
+    const [current, lv] = q.shift();
+
+    if (answer.at(lv) === undefined) {
+      answer[lv] = [];
+    }
+
+    answer[lv].push(current.val);
+
+    if (current.left) {
+      q.push([current.left, lv + 1]);
+    }
+
+    if (current.right) {
+      q.push([current.right, lv + 1]);
+    }
+  }
+
+  return answer;
+};

binary-tree-level-order-traversal/mmyeon.ts

@@ -0,0 +1,86 @@
+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;
+  }
+}
+
+/**
+ *@link https://leetcode.com/problems/binary-tree-level-order-traversal/
+ *
+ * 접근 방법 : DFS 사용
+ *  - 같은 높이의 노드들을 result 배열에 넣기 위해서 dfs로 재귀 호출
+ *  - result 배열에 현재 level에 대한 배열이 없으면 추가하고, 현재 노드의 값을 push
+ *  - 하위 자식 노드가 존재하면 dfs 재귀 호출 (level은 1 증가)
+ *
+ * 시간복잡도 : O(n)
+ *  - n = 노드의 개수, 모든 노드 순회
+ *
+ * 공간복잡도 : O(n)
+ *  - 트리 기울어진 경우, 재귀 호출 n번 만큼 스택 사용
+ */
+
+function levelOrder(root: TreeNode | null): number[][] {
+  const result: number[][] = [];
+
+  const dfs = (node: TreeNode | null, level: number) => {
+    if (!node) return;
+
+    if (!result[level]) result[level] = [];
+
+    result[level].push(node.val);
+
+    if (node.left) dfs(node.left, level + 1);
+    if (node.right) dfs(node.right, level + 1);
+  };
+
+  dfs(root, 0);
+
+  return result;
+}
+
+/**
+ *
+ * 접근 방법 : BFS 사용
+ *  - 동일 레벨의 노드 값 담기 위해서 큐를 사용
+ *  - 탐색할 노드를 큐에 먼저 담고, 큐에서 하나씩 꺼내면서 동일 레벨의 노드 값 담기
+ *  - 노드의 자식노드가 존재하면 다시 큐에 추가해서 탐색할 수 있도록 함
+ *  - 이 과정 반복하기
+ *
+ * 시간복잡도 : O(n)
+ *  - n = 노드의 개수, 모든 노드 순회
+ *
+ * 공간복잡도 : O(n)
+ *  - 큐에 모든 노드 저장함
+ */
+
+function levelOrder(root: TreeNode | null): number[][] {
+  if (!root) return [];
+
+  // 탐색할 노드 담아놓는 대기줄
+  const queue: TreeNode[] = [root];
+  const result: number[][] = [];
+
+  while (queue.length > 0) {
+    // 동일 레벨에 있는 노드 값 담는 용도
+    const currentLevel: number[] = [];
+    // queue 사이즈가 동적으로 변하기 때문에 미리 계산한 값 변수에 저장
+    const size = queue.length;
+
+    for (let i = 0; i < size; i++) {
+      const node = queue.shift()!;
+      currentLevel.push(node.val);
+
+      if (node.left) queue.push(node.left);
+      if (node.right) queue.push(node.right);
+    }
+
+    result.push(currentLevel);
+  }
+
+  return result;
+}