Merge branch 'DaleStudy:main' into main

Author: KwonNayeon

alien-dictionary/PDKhan.cpp

@@ -0,0 +1,67 @@
+class Solution {
+public:
+    string alienOrder(vector<string> &words) {
+        // Write your code here
+        unordered_map<char, unordered_set<char>> graph;
+        unordered_map<char, int> indegree;
+        unordered_set<char> all_chars;
+
+        for (const string& word : words) {
+            for (char c : word) {
+                all_chars.insert(c);
+                if (!indegree.count(c))
+                    indegree[c] = 0;
+            }
+        }
+
+        for(int i = 0; i < words.size() - 1; i++){
+            string word1 = words[i];
+            string word2 = words[i + 1];
+            int len = min(word1.size(), word2.size());
+            bool found = false;
+
+            for(int j = 0; j < len; j++){
+                char ch1 = word1[j];
+                char ch2 = word2[j];
+
+                if(ch1 != ch2){
+                    if(graph[ch1].count(ch2) == 0){
+                        graph[ch1].insert(ch2);
+                        indegree[ch2]++;
+                    }
+
+                    found = true;
+                    break;
+                }
+            }
+
+            if(!found && word1.size() > word2.size())
+                return "";
+        }
+
+        queue<char> q;
+        for(char c : all_chars){
+            if(indegree[c] == 0)
+                q.push(c);
+        }
+
+        string order;
+
+        while(!q.empty()){
+            char cur = q.front();
+            q.pop();
+
+            order += cur;
+
+            for(char next : graph[cur]){
+                if(--indegree[next] == 0)
+                    q.push(next);
+            }
+        }
+
+        if(order.size() != all_chars.size())
+            return "";
+
+        return order;
+    }
+};

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

@@ -0,0 +1,41 @@
+/**
+ * [Problem]: [102] Binary Tree Level Order Traversal
+ * (https://leetcode.com/problems/binary-tree-level-order-traversal/description/)
+ */
+
+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;
+    }
+}
+
+// 시간복잡도 O(n)
+// 공간복잡도 O(n)
+function levelOrder(root: TreeNode | null): number[][] {
+    if (!root) return [];
+
+    const result: number[][] = [];
+    const queue: TreeNode[] = [root];
+
+    while (queue.length > 0) {
+        const level = queue.length;
+        const values: number[] = [];
+
+        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/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/JustHm.swift

@@ -0,0 +1,17 @@
+// 재귀 함수로 해결
+// 각 노드의 레벨을 기억하고있다가 정답변수에 레벨별로 노드값을 넣어줌
+class Solution {
+    func levelOrder(_ root: TreeNode?) -> [[Int]] {
+        var answer = [[Int]]()
+        searchNodes(0, root, &answer)
+        return answer
+    }
+
+    func searchNodes(_ level: Int, _ node: TreeNode?, _ answer: inout [[Int]]) {
+        guard let node else { return }
+        if level >= answer.count { answer.append([]) }
+        answer[level].append(node.val)
+        searchNodes(level + 1, node.left, &answer)
+        searchNodes(level + 1, node.right, &answer)
+    }
+}

binary-tree-level-order-traversal/PDKhan.cpp

@@ -0,0 +1,35 @@
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> result;
+
+        if(!root)
+            return result;
+
+        queue<TreeNode*> q;
+
+        q.push(root);
+
+        while(!q.empty()){
+            int len = q.size();
+            vector<int> level;
+
+            for(int i = 0; i < len; i++){
+                TreeNode* curr = q.front();
+                q.pop();
+
+                if(curr->left)
+                    q.push(curr->left);
+                
+                if(curr->right)
+                    q.push(curr->right);
+
+                level.push_back(curr->val);
+            }
+
+            result.push_back(level);
+        }
+
+        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/crumbs22.cpp

@@ -0,0 +1,32 @@
+/*
+	queue를 활용해서 자식 노드의 수를 세고, 그만큼 반복문을 돌면서
+	각 노드의 값을 저장하는 방식으로 깊이순 트리 순회를 구현
+	트리의 모든 노드를 한 번씩 방문하므로 O(n)의 시간복잡도,
+	트리의 모든 노드를 저장하므로 O(n)의 공간 복잡도를 가진다.
+*/
+class Solution {
+	public:
+		vector<vector<int>> levelOrder(TreeNode* root) {
+			queue<TreeNode*> q;
+			vector<vector<int>> ans;
+			if (!root)
+				return ans;
+	
+			q.push(root);
+			while (!q.empty()) {
+				vector<int> tmp;
+				int size = q.size();
+				for (int i = 0; i < size; i++) {
+					TreeNode* child = q.front();
+					q.pop();
+					tmp.push_back(child->val);
+					if (child->left)
+						q.push(child->left);
+					if (child->right)
+						q.push(child->right);
+				}
+				ans.push_back(tmp);
+			}
+			return ans;
+		}
+	};

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

@@ -0,0 +1,33 @@
+// https://leetcode.com/problems/binary-tree-level-order-traversal/description/
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun levelOrder(root: TreeNode?): List<List<Int>> {
+        val result = mutableListOf<List<Int>>()
+        if(root == null) return result
+
+        val queue: ArrayDeque<TreeNode> = ArrayDeque()
+        queue.add(root)
+        
+        while (queue.isNotEmpty()) {
+            val levelSize = queue.size
+            val level = mutableListOf<Int>()
+            repeat(levelSize) {
+                val node = queue.removeFirst()
+                level.add(node.`val`)
+                node.left?.let { queue.add(it) }
+                node.right?.let { queue.add(it) }
+            }
+            result.add(level)
+        }
+        return result
+    }
+}