Merge branch 'DaleStudy:main' into main

Author: eunhwa99

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/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()
+ */

find-median-from-data-stream/hsskey.js

@@ -0,0 +1,101 @@
+class Heap {
+    constructor(compare) {
+        this.data = [];
+        this.compare = compare;
+    }
+
+    size() {
+        return this.data.length;
+    }
+
+    peek() {
+        return this.data[0];
+    }
+
+    push(val) {
+        this.data.push(val);
+        this._siftUp();
+    }
+
+    pop() {
+        const top = this.peek();
+        const bottom = this.data.pop();
+        if (this.data.length > 0) {
+            this.data[0] = bottom;
+            this._siftDown();
+        }
+        return top;
+    }
+
+    _siftUp() {
+        let i = this.data.length - 1;
+        const node = this.data[i];
+        while (i > 0) {
+            const parent = Math.floor((i - 1) / 2);
+            if (this.compare(node, this.data[parent])) {
+                this.data[i] = this.data[parent];
+                i = parent;
+            } else break;
+        }
+        this.data[i] = node;
+    }
+
+    _siftDown() {
+        let i = 0;
+        const node = this.data[0];
+        const length = this.data.length;
+
+        while (true) {
+            let left = 2 * i + 1;
+            let right = 2 * i + 2;
+            let swap = i;
+
+            if (left < length && this.compare(this.data[left], this.data[swap])) {
+                swap = left;
+            }
+            if (right < length && this.compare(this.data[right], this.data[swap])) {
+                swap = right;
+            }
+            if (swap === i) break;
+
+            this.data[i] = this.data[swap];
+            i = swap;
+        }
+
+        this.data[i] = node;
+    }
+}
+
+var MedianFinder = function() {
+    this.small = new Heap((a, b) => a > b); // max heap
+    this.large = new Heap((a, b) => a < b); // min heap
+};
+
+MedianFinder.prototype.addNum = function(num) {
+    this.small.push(num);
+
+    if (
+        this.small.size() > 0 &&
+        this.large.size() > 0 &&
+        this.small.peek() > this.large.peek()
+    ) {
+        this.large.push(this.small.pop());
+    }
+
+    if (this.small.size() > this.large.size() + 1) {
+        this.large.push(this.small.pop());
+    }
+    if (this.large.size() > this.small.size() + 1) {
+        this.small.push(this.large.pop());
+    }
+};
+
+MedianFinder.prototype.findMedian = function() {
+    if (this.small.size() > this.large.size()) {
+        return this.small.peek();
+    }
+    if (this.large.size() > this.small.size()) {
+        return this.large.peek();
+    }
+    return (this.small.peek() + this.large.peek()) / 2;
+};

find-median-from-data-stream/minji-go.java

@@ -0,0 +1,45 @@
+/**
+ * <a href="https://leetcode.com/problems/find-median-from-data-stream/">week13-4. find-median-from-data-stream</a>
+ * <li>Description: Implement the MedianFinder class</li>
+ * <li>Topics: Two Pointers, Design, Sorting, Heap (Priority Queue), Data Stream</li>
+ * <li>Time Complexity: O(logN), Runtime 99ms   </li>
+ * <li>Space Complexity: O(N), Memory 63.68MB   </li>
+ */
+
+class MedianFinder {
+    PriorityQueue<Integer> head;
+    PriorityQueue<Integer> tail;
+
+    public MedianFinder() {
+        head = new PriorityQueue<>(Comparator.reverseOrder());
+        tail = new PriorityQueue<>();
+    }
+
+    public void addNum(int num) {
+        if(head.isEmpty() || num <= head.peek()) {
+            head.add(num);
+        } else {
+            tail.add(num);
+        }
+
+        if (head.size() > tail.size() + 1) {
+            tail.add(head.poll());
+        } else if (head.size() < tail.size()) {
+            head.add(tail.poll());
+        }
+    }
+
+    public double findMedian() {
+        if(head.size() == tail.size()){
+            return ((double)head.peek() + tail.peek()) / 2;
+        }
+        return head.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/shinsj4653.py

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

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

@@ -0,0 +1,68 @@
+/*
+    풀이 :
+        maxHeap과 minHeap 사용
+
+        heap에 담긴 총 수 : N
+
+        addNum()
+            작은 수 집합은 maxHeap, 큰 수 집합은 minHeap에 담는다
+            minHeap과 maxHeap의 개수차이를 1로 유지하면서 addNum
+
+            TC : O (log N)
+                힙에 넣고 뺄 때 O (logN) 의 시간 소요
+
+            SC : O (N)
+                총 힙 크기는 N에 비례
+
+        findMedian()
+            더 크게 유지되는 것은 minHeap이므로 둘 의 개수가 같지 않을경우(총 홀수개) minHeap.top() 리턴
+            같을 경우 총개수가 짝수개이므로 두 힙.top()의 평균을 리턴
+
+            TC : O (1)
+                각 힙에서 root값 확인은 O(1)의 시간 소요
+            SC : O (1)
+*/
+
+#include <queue>
+#include <vector>
+using namespace std;
+
+class MedianFinder {
+    public:
+        priority_queue<int> maxHeap;
+        priority_queue<int, vector<int>, greater<int>> minHeap;
+        
+        MedianFinder() {
+            
+        }
+        
+        void addNum(int num) {
+            if (minHeap.empty() || num >= minHeap.top())
+                minHeap.push(num);
+            else
+                maxHeap.push(num);
+            
+            if (minHeap.size() > maxHeap.size() + 1) {
+                maxHeap.push(minHeap.top());
+                minHeap.pop();
+            }
+            else if (maxHeap.size() > minHeap.size()) {
+                minHeap.push(maxHeap.top());
+                maxHeap.pop();
+            }
+        }
+        
+        double findMedian() {
+            if (maxHeap.size() == minHeap.size())
+                return static_cast<double>(maxHeap.top() + minHeap.top()) / 2;
+            else
+                return minHeap.top();
+        }
+    };
+    
+    /**
+     * Your MedianFinder object will be instantiated and called as such:
+     * MedianFinder* obj = new MedianFinder();
+     * obj->addNum(num);
+     * double param_2 = obj->findMedian();
+     */