Merge branch 'DaleStudy:main' into main

Author: hoyeongkwak

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

@@ -0,0 +1,42 @@
+ 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)
+     }
+ }
+
+
+// TC: O(n)
+// SC: O(n)
+function levelOrder(root: TreeNode | null): number[][] {
+  if (!root) return [];
+
+  const result: number[][] = [];
+  const queue: TreeNode[] = [root];
+
+  while (queue.length > 0) {
+    const values: number[] = [];
+    const level = queue.length;
+
+    for (let i = 0; i < level; i++) {
+      const node = queue.shift()!;
+      values.push(node.val);
+
+      if (node.left) {
+        queue.push(node.left);
+      }
+
+      if (node.right) {
+        queue.push(node.right);
+      }
+    }
+
+    result.push(values);
+  }
+
+  return result;
+}

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

@@ -0,0 +1,87 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * 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 {
+
+    // DFS 풀이
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        dfs(root, 0, result);
+        return result;
+    }
+
+    private void dfs(TreeNode node, int depth, List<List<Integer>> result) {
+        if (node == null) {
+            return;
+        }
+
+        // 깊이만큼의 리스트가 없으면 새 리스트 추가하기
+        if (depth == result.size()) {
+            result.add(new ArrayList<>());
+        }
+
+        result.get(depth).add(node.val);
+
+        dfs(node.left, depth + 1, result);
+        dfs(node.right, depth + 1, result);
+
+
+    }
+
+    // BFS로 풀이
+    // O(n)
+//    public List<List<Integer>> levelOrder(TreeNode root) {
+//
+//        List<List<Integer>> result = new ArrayList<>();
+//
+//        if (root == null) {
+//            return result;
+//        }
+//
+//        Queue<TreeNode> queue = new LinkedList<>();
+//        queue.offer(root);
+//
+//        while (!queue.isEmpty()) {
+//            int nodeCnt = queue.size();
+//            List<Integer> currentLevelNodes = new ArrayList<>();
+//
+//            for (int i = 0; i < nodeCnt; i++) {
+//                TreeNode current = queue.poll();
+//                currentLevelNodes.add(current.val);
+//
+//                if (current.left != null) {
+//                    queue.offer(current.left);
+//                }
+//
+//                if (current.right != null) {
+//                    queue.offer(current.right);
+//                }
+//
+//            }
+//
+//            result.add(currentLevelNodes);
+//
+//        }
+//
+//        return result;
+//
+//    }
+}
+

binary-tree-level-order-traversal/printjin-gmailcom.py

@@ -0,0 +1,13 @@
+class Solution:
+    def levelOrder(self, root):
+        result = []
+        def dfs(node, level):
+            if not node:
+                return
+            if len(result) == level:
+                result.append([])
+            result[level].append(node.val)
+            dfs(node.left, level + 1)
+            dfs(node.right, level + 1)
+        dfs(root, 0)
+        return result

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

@@ -0,0 +1,15 @@
+"""
+[문제풀이]
+# Inputs
+
+# Outputs
+
+# Constraints
+
+# Ideas
+
+[회고]
+
+"""
+
+

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

@@ -0,0 +1,40 @@
+# 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
+
+from collections import deque
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+
+        # BFS(큐 사용)
+        # 시간복잡도 O(n), 공간복잡도 O(n)
+
+        if not root:
+            return []
+        
+        # 큐에 root노드 추가(초기화)
+        q = deque([root])
+        answer = []
+
+        # 큐가 빌 때까지 탐색(모든 노드 탐색)
+        while q:
+            level = []  # 현재 레벨의 노드 저장할 리스트
+
+            for _ in range(len(q)):     # 현재 레벨에 있는 노드 수만큼 반복
+                node = q.popleft()      # 큐에서 노드 꺼내서
+                level.append(node.val)  # level에 저장
+
+                # 자식 노드들이 있다면 큐에 추가
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+            
+            # 현재 레벨 answer에 추가
+            answer.append(level)
+
+        return answer

counting-bits/Jeehay28.ts

@@ -0,0 +1,17 @@
+// TC: O(n)
+// SC: O(n)
+function countBits(n: number): number[] {
+  const dp: number[] = [];
+  dp[0] = 0;
+
+  for (let i = 0; i <= n; i++) {
+    dp[i] = dp[i >> 1] + (i & 1);
+  }
+
+  // The number of 1s in the quotient (i >> 1) + number of 1s in the remainder (i & 1)
+  // dp[i >> 1]: number of 1's in Math.floor(i / 2)
+  // i & 1: 1 if i is odd, 0 if even
+
+  return dp;
+}
+

counting-bits/Tessa1217.java

@@ -0,0 +1,14 @@
+class Solution {
+
+    // 시간복잡도: O(n)
+    public int[] countBits(int n) {
+        int[] bitsArray = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            // Shift 연산자 사용
+            // i&1 => 마지막 비트가 0인지 1인지 확인
+            bitsArray[i] = bitsArray[i >> 1] + (i & 1);
+        }
+        return bitsArray;
+    }
+}
+

counting-bits/byol-han.js

@@ -0,0 +1,16 @@
+/**
+ * https://leetcode.com/problems/counting-bits/submissions/1681218194/
+ * @param {number} n
+ * @return {number[]}
+ */
+var countBits = function (n) {
+  const ans = [];
+  for (let i = 0; i <= n; i++) {
+    // Convert i to binary with i.toString(2)
+    // Count 1s by splitting into chars, filtering '1', and getting length
+    const binary = i.toString(2);
+    const onesCount = binary.split('').filter((bit) => bit === '1').length;
+    ans.push(onesCount);
+  }
+  return ans;
+};

counting-bits/eunhwa99.kt

@@ -0,0 +1,29 @@
+class Solution {
+    /*
+    0 -> 0
+    1 -> 1
+    2 -> 1
+    3 -> 2
+    4 -> 1
+    5 -> 2
+    6 -> 2
+    7 -> 3
+    8 -> 1
+    9 -> 2
+    10 -> 2
+    11 -> 3
+    12 -> 2
+    2,4,8,16,.. -> 1
+    짝수: i/2의 1의 개수
+    홀수: i/2의 1의 개수 + 1
+     */
+    // TC: O(n)
+    // SC: O(n)
+    fun countBits(n: Int): IntArray {
+        val result = IntArray(n + 1)
+        for(i in 0..n) {
+            result[i] = result[i / 2] + (i % 2)
+        }
+        return result
+    }
+}

counting-bits/printjin-gmailcom.py

@@ -0,0 +1,6 @@
+class Solution:
+    def countBits(self, n):
+        ans = [0] * (n + 1)
+        for i in range(1, n + 1):
+            ans[i] = ans[i >> 1] + (i & 1)
+        return ans