Merge branch 'main' of https://github.com/eunhwa99/leetcode-study

Author: eunhwa99

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;
+//
+//    }
+}
+

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;
+    }
+}
+

find-median-from-data-stream/KwonNayeon.py

@@ -0,0 +1,43 @@
+"""
+Constraints:
+- -10^5 <= num <= 10^5
+- There will be at least one element in the data structure before calling findMedian.
+- At most 5 * 10^4 calls will be made to addNum and findMedian.
+
+Time Complexity: 
+- addNum(): O(nlogn)
+  - 매번 정렬하기 때문
+- findMedian(): O(1)
+  - 정렬된 리스트에서 인덱스 접근
+
+Space Complexity: O(n)
+- 입력된 모든 숫자를 리스트에 저장
+
+풀이방법:
+1. 리스트 자료구조 사용
+2. 리스트에 각 요소들 추가 후 정렬
+3. 리스트의 요소 갯수가 홀수/짝수일 때의 경우를 나눠서 median 값을 구함
+
+메모: 
+- heap이 익숙하지 않아서 일단 리스트로 문제를 풀었습니다.
+- 나중에 heap으로 다시 풀기
+"""
+class MedianFinder:
+
+    def __init__(self):
+        self.nums = []
+
+    def addNum(self, num: int) -> None:
+        self.nums.append(num)
+        self.nums.sort()
+        
+
+    def findMedian(self) -> float:
+        n = len(self.nums)
+        if n % 2 == 1:
+            return self.nums[n // 2]
+        else:
+            mid1 = self.nums[n // 2 - 1]
+            mid2 = self.nums[n // 2]
+            return (mid1 + mid2) / 2.0
+

find-median-from-data-stream/PDKhan.cpp

@@ -0,0 +1,31 @@
+class MedianFinder {
+    priority_queue<int> maxHeap;
+    priority_queue<int, vector<int>, greater<int>> minHeap;
+public:
+    MedianFinder() {   
+    }
+    
+    void addNum(int num) {
+        if(maxHeap.empty() || num <= maxHeap.top())
+            maxHeap.push(num);
+        else
+            minHeap.push(num);
+
+        if(maxHeap.size() > minHeap.size() + 1){
+            minHeap.push(maxHeap.top());
+            maxHeap.pop();
+        }else if(maxHeap.size() < minHeap.size()){
+            maxHeap.push(minHeap.top());
+            minHeap.pop();
+        }
+    }
+    
+    double findMedian() {
+        if(maxHeap.size() > minHeap.size())
+            return maxHeap.top();
+        else if(maxHeap.size() < minHeap.size())
+            return minHeap.top();
+        else
+            return (maxHeap.top() + minHeap.top()) / 2.0;
+    }
+};

find-median-from-data-stream/Tessa1217.java

@@ -0,0 +1,46 @@
+import java.util.PriorityQueue;
+
+class MedianFinder {
+
+    // 작은 수 범위 저장하는 힙
+    private PriorityQueue<Integer> smallHeap;
+
+    // 큰 수 범위 저장하는 힙
+    private PriorityQueue<Integer> largeHeap;
+
+    public MedianFinder() {
+        smallHeap = new PriorityQueue<>((a, b) -> b - a);
+        largeHeap = new PriorityQueue<> ((a, b) -> a - b);
+    }
+
+    public void addNum(int num) {
+        // 작은 수 범위에 삽입
+        smallHeap.offer(num);
+        // 작은 수 범위에서 최댓값을 뽑아 큰 수 범위로 이동
+        largeHeap.offer(smallHeap.poll());
+
+        // 만약 작은 수 범위의 개수가 큰 수 범위보다 작다면
+        if (smallHeap.size() < largeHeap.size()) {
+            // 큰 수 범위에서 최솟값을 뽑아 작은 수 범위로 이동
+            smallHeap.offer(largeHeap.poll());
+        }
+    }
+
+    public double findMedian() {
+        // 짝수 개일 경우
+        if (smallHeap.size() == largeHeap.size()) {
+            // 작은 수 범위 힙의 최댓값 + 큰 수 범위 힙의 최솟값의 평균
+            return (smallHeap.peek() + largeHeap.peek()) / 2.0;
+        }
+        // 작은 수 범위 힙의 최댓값
+        return smallHeap.peek();
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */
+

find-median-from-data-stream/crumbs22.cpp

@@ -0,0 +1,39 @@
+/*
+    minHeap이 항상 maxHeap보다 크거나 같도록 유지한다.
+    addNum()
+        - maxHeap에 새로 들어온 num을 포함한 최댓값을 minHeap으로 옮긴다
+        - 처음엔 maxHeap과 minHeap의 크기 차이가 1이므로 if문에 들어가지 않지만
+        - 이후 num이 minHeap으로 하나 더 넘어가게 되면 maxHeap과 minHeap의 크기 차이가 2가 되므로 
+            if문에 들어가서 maxHeap쪽으로 minHeap의 최솟값을 옮긴다
+        힙 삽입에 O(logn)이 걸리므로 시간복잡도는 O(logn)이다
+    findMedian()
+        - 두 힙의 top만 참조하면 되므로 시간 복잡도는 O(1)이다
+    최소힙과 최대힙은 각각 전체 수의 절반씩을 저장한다.
+    공간 복잡도는 O(n)이다
+*/
+class MedianFinder {
+public:
+    priority_queue<int> maxHeap;
+    priority_queue<int, vector<int>, greater<int>> minHeap;
+    
+    MedianFinder() {
+    }
+    
+    void addNum(int num) {
+        maxHeap.push(num);
+        
+        minHeap.push(maxHeap.top());
+        maxHeap.pop();
+
+        if (maxHeap.size() + 1 < minHeap.size()) {
+            maxHeap.push(minHeap.top());
+            minHeap.pop();
+        }
+    }
+
+    double findMedian() {
+        if (maxHeap.size() == minHeap.size())
+            return (minHeap.top() + maxHeap.top()) / 2.0;
+        return minHeap.top();
+    }
+};

find-median-from-data-stream/hoyeongkwak.ts

@@ -0,0 +1,43 @@
+class MedianFinder {
+    arr: number[]
+    constructor() {
+        this.arr = []
+    }
+    /*
+    Time Complexity: O(logn)
+    Space Complexity: O(n)
+    */
+    addNum(num: number): void {
+        let left = 0
+        let right = this.arr.length
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2)
+            if (this.arr[mid] < num) {
+                left = mid + 1
+            } else {
+                right = mid
+            }
+        }
+        this.arr.splice(left, 0, num)
+    }
+    /*
+    Time Complexity: O(1)
+    Space Complexity: O(n)
+    */
+    findMedian(): number {
+        const n = this.arr.length
+        if (n % 2 === 0) {
+            return (this.arr[n / 2 - 1] + this.arr[n / 2]) / 2
+        } else {
+            return (this.arr[Math.floor(n / 2)])
+        }
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * var obj = new MedianFinder()
+ * obj.addNum(num)
+ * var param_2 = obj.findMedian()
+ */