Merge branch 'DaleStudy:main' into main

Author: doh6077

binary-tree-level-order-traversal/8804who.py

@@ -0,0 +1,29 @@
+from collections import deque
+
+# 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]]:
+        answer = []
+        
+        q = deque([(root, 0)])
+
+        while q:
+            node, depth = q.popleft()
+            if not node:
+                continue
+            
+            if len(answer)-1 < depth:
+                answer.append([])
+ 
+            answer[depth].append(node.val)
+
+            q.append((node.left, depth+1))
+            q.append((node.right, depth+1))
+
+        return answer
+    

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

@@ -0,0 +1,31 @@
+''''
+Time Complexity: O(N)
+- 모든 노드를 한 번씩 방문하므로 O(N)
+
+Space Complexity: O(N)
+- 결과를 저장하기 위해 values 리스트와 큐에 최대 N개의 노드가 저장
+'''
+from collections import deque
+
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        result = []
+        
+        if not root:
+            return result
+
+        queue = deque([root])
+
+        while queue:
+            values = []
+            for _ in range(len(queue)): # 같은 레벨에 있는 노드를 함께 처리
+                node = queue.popleft()
+                values.append(node.val)
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            
+            result.append(values)
+        
+        return result

binary-tree-level-order-traversal/juhui-jeong.java

@@ -0,0 +1,26 @@
+// BFS 구현
+// null 처리 잘 확인할 것...
+class Solution {
+    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 size = queue.size();
+            List<Integer> level = new ArrayList<>();
+
+            for (int i = 0; i < size; i++) {
+                TreeNode cur = queue.poll();
+                level.add(cur.val);
+
+                if (cur.left != null) queue.offer(cur.left);
+                if (cur.right != null) queue.offer(cur.right);
+            }
+            result.add(level);
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,30 @@
+# 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
+
+
+# idea: BFS 
+# Time Complexity: O(n)
+from collections import deque
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        ans = []
+        q = deque([root])
+        while q:
+            level = []
+            for i in range(len(q)):
+                node = q.popleft() 
+                if node:
+                    level.append(node.val) 
+                    if node.left:
+                        q.append(node.left) 
+                    if node.right:
+                        q.append(node.right) 
+            if level:
+                ans.append(level)
+        return ans
+
+

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

@@ -0,0 +1,42 @@
+from collections import deque, defaultdict
+from typing import Optional, List
+
+# 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]]:
+        # 앞으로의 코드는 root가 있다는 것을 전제로 수행
+        # 또한 root가 None이라면 기록해서 돌려 줄 값도 없기 때문에 early return
+        if not root:
+            return []
+
+        # depth별 노드를 기록할 defaultdict
+        nodes = defaultdict(list)
+        # bfs 탐색에 사용될 queue
+        queue = deque()
+
+        # root는 존재함이 보장되므로, 반복문의 시동을 위해 root node를 queue에 추가
+        # 이 때 깊이 정보도 함께 묶어서 tuple로 추가
+        queue.append((root, 0))
+
+        while queue:
+            current = queue.popleft()
+
+            # 현재 노드의 값 기록
+            nodes[current[1]].append(current[0].val)
+
+            # 현재 노드의 왼쪽 자식 노드가 존재한다면, 해당 노드와 깊이 정보를 함께 queue에 추가
+            if current[0].left:
+                queue.append((current[0].left, current[1] + 1))
+                
+            # 현재 노드의 오른쪽 자식 노드가 존재한다면, 해당 노드와 깊이 정보를 함께 queue에 추가
+            if current[0].right:
+                queue.append((current[0].right, current[1] + 1))
+
+        # 깊이 순서대로 dict에 추가되었으므로, values()를 사용하여 리스트로 변환하여 반환
+        return list(nodes.values())

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

@@ -0,0 +1,27 @@
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        if(root == null) {
+            return new ArrayList<>();
+        }
+        List<List<Integer>> list = new ArrayList<>();
+        dfs(root, 0, list);
+        return list;
+    }
+
+    public void dfs(TreeNode node, int depth, List<List<Integer>> list) {
+        if(list.size() == depth) {
+            list.add(new ArrayList<>());
+        }
+
+        List<Integer> dest = list.get(depth);
+        dest.add(node.val);
+
+        if(node.left != null) {
+            dfs(node.left, depth + 1, list);
+        }
+
+        if(node.right != null) {
+            dfs(node.right, depth + 1, list);
+        }
+    }
+}

binary-tree-level-order-traversal/ys-han00.cpp

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> ans;
+    void rec(TreeNode* curr, int level) {
+        if(ans.size() < level)
+            ans.push_back(vector<int>());
+        ans[level - 1].push_back(curr->val);
+        if(curr->left)
+            rec(curr->left, level + 1);
+        if(curr->right)
+            rec(curr->right, level + 1);
+    }
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        if(root)
+            rec(root, 1);
+        return ans;
+    }
+};
+

counting-bits/8804who.py

@@ -0,0 +1,22 @@
+import math
+
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        dp = [0, 1]
+        num = 1
+        idx = 2
+
+        while idx <= n:
+            num *= 2
+            temp = idx+(num//2)
+            temp2 = temp+(num//2)
+
+            for i in range(idx, temp):
+                dp.append(dp[i-(num//2)])
+                idx += 1
+            for i in range(temp,temp2):
+                dp.append(dp[i-(num//2)]+1)
+                idx += 1
+        
+        return dp[:n+1]
+    

counting-bits/hjeomdev.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int[] countBits(int n) {
+        // 0 ~ n 까지 2진수를 구하고, 그 수의 모든 자릿값의 합을 구해야함
+
+        int[] result = new int[n + 1];
+
+        for (int i = 0; i <= n; i++) {
+            String binaryString = Integer.toBinaryString(i);
+            int sum = 0;
+            for (int j = 0 ; j < binaryString.length(); j++) {
+                sum += binaryString.charAt(j) - '0';
+            }
+            result[i] = sum;
+        }
+
+        return result;
+    }
+}

counting-bits/juhui-jeong.java

@@ -0,0 +1,24 @@
+
+
+class Solution {
+    public int[] countBits(int n) {
+        ArrayList<Integer> list = new ArrayList<>();
+
+        for (int i = 0; i <= n; i++) {
+            int result = i;
+            int cnt = 0;
+
+            while(result > 0) {
+                cnt += result%2;
+                result /= 2;
+            }
+
+            list.add(cnt);
+        }
+        int[] ans = new int[list.size()];
+        for (int i = 0; i < list.size(); i++) {
+            ans[i] = list.get(i);
+        }
+        return ans;
+    }
+}