Skip to content

Commit c5c511a

Browse files
author
eunhwa99
committed
2 parents 42c0b2e + eb472eb commit c5c511a

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

56 files changed

+2072
-2
lines changed
Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
import java.util.ArrayList;
2+
import java.util.LinkedList;
3+
import java.util.List;
4+
import java.util.Queue;
5+
6+
/**
7+
* Definition for a binary tree node.
8+
* public class TreeNode {
9+
* int val;
10+
* TreeNode left;
11+
* TreeNode right;
12+
* TreeNode() {}
13+
* TreeNode(int val) { this.val = val; }
14+
* TreeNode(int val, TreeNode left, TreeNode right) {
15+
* this.val = val;
16+
* this.left = left;
17+
* this.right = right;
18+
* }
19+
* }
20+
*/
21+
class Solution {
22+
23+
// DFS 풀이
24+
public List<List<Integer>> levelOrder(TreeNode root) {
25+
List<List<Integer>> result = new ArrayList<>();
26+
dfs(root, 0, result);
27+
return result;
28+
}
29+
30+
private void dfs(TreeNode node, int depth, List<List<Integer>> result) {
31+
if (node == null) {
32+
return;
33+
}
34+
35+
// 깊이만큼의 리스트가 없으면 새 리스트 추가하기
36+
if (depth == result.size()) {
37+
result.add(new ArrayList<>());
38+
}
39+
40+
result.get(depth).add(node.val);
41+
42+
dfs(node.left, depth + 1, result);
43+
dfs(node.right, depth + 1, result);
44+
45+
46+
}
47+
48+
// BFS로 풀이
49+
// O(n)
50+
// public List<List<Integer>> levelOrder(TreeNode root) {
51+
//
52+
// List<List<Integer>> result = new ArrayList<>();
53+
//
54+
// if (root == null) {
55+
// return result;
56+
// }
57+
//
58+
// Queue<TreeNode> queue = new LinkedList<>();
59+
// queue.offer(root);
60+
//
61+
// while (!queue.isEmpty()) {
62+
// int nodeCnt = queue.size();
63+
// List<Integer> currentLevelNodes = new ArrayList<>();
64+
//
65+
// for (int i = 0; i < nodeCnt; i++) {
66+
// TreeNode current = queue.poll();
67+
// currentLevelNodes.add(current.val);
68+
//
69+
// if (current.left != null) {
70+
// queue.offer(current.left);
71+
// }
72+
//
73+
// if (current.right != null) {
74+
// queue.offer(current.right);
75+
// }
76+
//
77+
// }
78+
//
79+
// result.add(currentLevelNodes);
80+
//
81+
// }
82+
//
83+
// return result;
84+
//
85+
// }
86+
}
87+

counting-bits/Tessa1217.java

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
3+
// 시간복잡도: O(n)
4+
public int[] countBits(int n) {
5+
int[] bitsArray = new int[n + 1];
6+
for (int i = 1; i <= n; i++) {
7+
// Shift 연산자 사용
8+
// i&1 => 마지막 비트가 0인지 1인지 확인
9+
bitsArray[i] = bitsArray[i >> 1] + (i & 1);
10+
}
11+
return bitsArray;
12+
}
13+
}
14+
Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
"""
2+
Constraints:
3+
- -10^5 <= num <= 10^5
4+
- There will be at least one element in the data structure before calling findMedian.
5+
- At most 5 * 10^4 calls will be made to addNum and findMedian.
6+
7+
Time Complexity:
8+
- addNum(): O(nlogn)
9+
- 매번 정렬하기 때문
10+
- findMedian(): O(1)
11+
- 정렬된 리스트에서 인덱스 접근
12+
13+
Space Complexity: O(n)
14+
- 입력된 모든 숫자를 리스트에 저장
15+
16+
풀이방법:
17+
1. 리스트 자료구조 사용
18+
2. 리스트에 각 요소들 추가 후 정렬
19+
3. 리스트의 요소 갯수가 홀수/짝수일 때의 경우를 나눠서 median 값을 구함
20+
21+
메모:
22+
- heap이 익숙하지 않아서 일단 리스트로 문제를 풀었습니다.
23+
- 나중에 heap으로 다시 풀기
24+
"""
25+
class MedianFinder:
26+
27+
def __init__(self):
28+
self.nums = []
29+
30+
def addNum(self, num: int) -> None:
31+
self.nums.append(num)
32+
self.nums.sort()
33+
34+
35+
def findMedian(self) -> float:
36+
n = len(self.nums)
37+
if n % 2 == 1:
38+
return self.nums[n // 2]
39+
else:
40+
mid1 = self.nums[n // 2 - 1]
41+
mid2 = self.nums[n // 2]
42+
return (mid1 + mid2) / 2.0
43+
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
class MedianFinder {
2+
priority_queue<int> maxHeap;
3+
priority_queue<int, vector<int>, greater<int>> minHeap;
4+
public:
5+
MedianFinder() {
6+
}
7+
8+
void addNum(int num) {
9+
if(maxHeap.empty() || num <= maxHeap.top())
10+
maxHeap.push(num);
11+
else
12+
minHeap.push(num);
13+
14+
if(maxHeap.size() > minHeap.size() + 1){
15+
minHeap.push(maxHeap.top());
16+
maxHeap.pop();
17+
}else if(maxHeap.size() < minHeap.size()){
18+
maxHeap.push(minHeap.top());
19+
minHeap.pop();
20+
}
21+
}
22+
23+
double findMedian() {
24+
if(maxHeap.size() > minHeap.size())
25+
return maxHeap.top();
26+
else if(maxHeap.size() < minHeap.size())
27+
return minHeap.top();
28+
else
29+
return (maxHeap.top() + minHeap.top()) / 2.0;
30+
}
31+
};
Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,46 @@
1+
import java.util.PriorityQueue;
2+
3+
class MedianFinder {
4+
5+
// 작은 수 범위 저장하는 힙
6+
private PriorityQueue<Integer> smallHeap;
7+
8+
// 큰 수 범위 저장하는 힙
9+
private PriorityQueue<Integer> largeHeap;
10+
11+
public MedianFinder() {
12+
smallHeap = new PriorityQueue<>((a, b) -> b - a);
13+
largeHeap = new PriorityQueue<> ((a, b) -> a - b);
14+
}
15+
16+
public void addNum(int num) {
17+
// 작은 수 범위에 삽입
18+
smallHeap.offer(num);
19+
// 작은 수 범위에서 최댓값을 뽑아 큰 수 범위로 이동
20+
largeHeap.offer(smallHeap.poll());
21+
22+
// 만약 작은 수 범위의 개수가 큰 수 범위보다 작다면
23+
if (smallHeap.size() < largeHeap.size()) {
24+
// 큰 수 범위에서 최솟값을 뽑아 작은 수 범위로 이동
25+
smallHeap.offer(largeHeap.poll());
26+
}
27+
}
28+
29+
public double findMedian() {
30+
// 짝수 개일 경우
31+
if (smallHeap.size() == largeHeap.size()) {
32+
// 작은 수 범위 힙의 최댓값 + 큰 수 범위 힙의 최솟값의 평균
33+
return (smallHeap.peek() + largeHeap.peek()) / 2.0;
34+
}
35+
// 작은 수 범위 힙의 최댓값
36+
return smallHeap.peek();
37+
}
38+
}
39+
40+
/**
41+
* Your MedianFinder object will be instantiated and called as such:
42+
* MedianFinder obj = new MedianFinder();
43+
* obj.addNum(num);
44+
* double param_2 = obj.findMedian();
45+
*/
46+
Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
/*
2+
minHeap이 항상 maxHeap보다 크거나 같도록 유지한다.
3+
addNum()
4+
- maxHeap에 새로 들어온 num을 포함한 최댓값을 minHeap으로 옮긴다
5+
- 처음엔 maxHeap과 minHeap의 크기 차이가 1이므로 if문에 들어가지 않지만
6+
- 이후 num이 minHeap으로 하나 더 넘어가게 되면 maxHeap과 minHeap의 크기 차이가 2가 되므로
7+
if문에 들어가서 maxHeap쪽으로 minHeap의 최솟값을 옮긴다
8+
힙 삽입에 O(logn)이 걸리므로 시간복잡도는 O(logn)이다
9+
findMedian()
10+
- 두 힙의 top만 참조하면 되므로 시간 복잡도는 O(1)이다
11+
최소힙과 최대힙은 각각 전체 수의 절반씩을 저장한다.
12+
공간 복잡도는 O(n)이다
13+
*/
14+
class MedianFinder {
15+
public:
16+
priority_queue<int> maxHeap;
17+
priority_queue<int, vector<int>, greater<int>> minHeap;
18+
19+
MedianFinder() {
20+
}
21+
22+
void addNum(int num) {
23+
maxHeap.push(num);
24+
25+
minHeap.push(maxHeap.top());
26+
maxHeap.pop();
27+
28+
if (maxHeap.size() + 1 < minHeap.size()) {
29+
maxHeap.push(minHeap.top());
30+
minHeap.pop();
31+
}
32+
}
33+
34+
double findMedian() {
35+
if (maxHeap.size() == minHeap.size())
36+
return (minHeap.top() + maxHeap.top()) / 2.0;
37+
return minHeap.top();
38+
}
39+
};
Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
class MedianFinder {
2+
arr: number[]
3+
constructor() {
4+
this.arr = []
5+
}
6+
/*
7+
Time Complexity: O(logn)
8+
Space Complexity: O(n)
9+
*/
10+
addNum(num: number): void {
11+
let left = 0
12+
let right = this.arr.length
13+
14+
while (left < right) {
15+
const mid = Math.floor((left + right) / 2)
16+
if (this.arr[mid] < num) {
17+
left = mid + 1
18+
} else {
19+
right = mid
20+
}
21+
}
22+
this.arr.splice(left, 0, num)
23+
}
24+
/*
25+
Time Complexity: O(1)
26+
Space Complexity: O(n)
27+
*/
28+
findMedian(): number {
29+
const n = this.arr.length
30+
if (n % 2 === 0) {
31+
return (this.arr[n / 2 - 1] + this.arr[n / 2]) / 2
32+
} else {
33+
return (this.arr[Math.floor(n / 2)])
34+
}
35+
}
36+
}
37+
38+
/**
39+
* Your MedianFinder object will be instantiated and called as such:
40+
* var obj = new MedianFinder()
41+
* obj.addNum(num)
42+
* var param_2 = obj.findMedian()
43+
*/

0 commit comments

Comments
 (0)