Skip to content

Commit 96dfd49

Browse files
dev-jonghoonparkdev-jonghoonpark
committed
add posts
1 parent f281574 commit 96dfd49

File tree

5 files changed

+413
-0
lines changed

5 files changed

+413
-0
lines changed

‎_posts/2024-06-23-leetcode-105.md

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
---
2+
layout: post
3+
title: (Leetcode) 105 - Construct Binary Tree from Preorder and Inorder Traversal
4+
categories: [스터디-알고리즘]
5+
tags:
6+
[자바, java, 리트코드, Leetcode, 알고리즘, tree, traversal, inorder, preorder]
7+
date: 2024-06-23 09:30:00 +0900
8+
toc: true
9+
---
10+
11+
기회가 되어 [달레님의 스터디](https://github.com/DaleStudy/leetcode-study)에 참여하여 시간이 될 때마다 한문제씩 풀어보고 있다.
12+
13+
[https://neetcode.io/practice](https://neetcode.io/practice)
14+
15+
---
16+
17+
[https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/)
18+
19+
```java
20+
class Solution {
21+
public TreeNode buildTree(int[] preorder, int[] inorder) {
22+
Map<Integer, Integer> inorderIndexMap = new HashMap<>();
23+
for (int i = 0; i < inorder.length; i++) {
24+
inorderIndexMap.put(inorder[i], i);
25+
}
26+
27+
return buildTree(inorderIndexMap, new Traversal(preorder), new Traversal(inorder));
28+
}
29+
30+
public TreeNode buildTree(Map<Integer, Integer> inorderIndexMap, Traversal preorderTraversal, Traversal inorderTraversal) {
31+
if(preorderTraversal.start > preorderTraversal.end) {
32+
return null;
33+
}
34+
35+
TreeNode treeNode = new TreeNode(preorderTraversal.getFirst());
36+
if(preorderTraversal.start == preorderTraversal.end) {
37+
return treeNode;
38+
}
39+
40+
int rootIndex = inorderIndexMap.get(preorderTraversal.getFirst());
41+
int leftSize = rootIndex - inorderTraversal.start;
42+
treeNode.left = buildTree(
43+
inorderIndexMap,
44+
preorderTraversal.subIterator(preorderTraversal.start + 1, preorderTraversal.start + leftSize),
45+
inorderTraversal.subIterator(inorderTraversal.start, rootIndex - 1)
46+
);
47+
treeNode.right = buildTree(
48+
inorderIndexMap,
49+
preorderTraversal.subIterator(preorderTraversal.start + leftSize + 1, preorderTraversal.end),
50+
inorderTraversal.subIterator(rootIndex + 1, inorderTraversal.end)
51+
);
52+
53+
return treeNode;
54+
}
55+
}
56+
57+
class TreeNode {
58+
int val;
59+
TreeNode left;
60+
TreeNode right;
61+
62+
TreeNode() {
63+
}
64+
65+
TreeNode(int val) {
66+
this.val = val;
67+
}
68+
69+
TreeNode(int val, TreeNode left, TreeNode right) {
70+
this.val = val;
71+
this.left = left;
72+
this.right = right;
73+
}
74+
75+
@Override
76+
public String toString() {
77+
return "{" +
78+
"val=" + val +
79+
", left=" + left +
80+
", right=" + right +
81+
'}';
82+
}
83+
}
84+
85+
class Traversal {
86+
int[] array;
87+
int start;
88+
int end;
89+
90+
public Traversal(int[] array) {
91+
this.array = array;
92+
this.start = 0;
93+
this.end = array.length - 1;
94+
}
95+
96+
private Traversal(int[] array, int start, int end) {
97+
this.array = array;
98+
this.start = start;
99+
this.end = end;
100+
}
101+
102+
public Traversal subIterator(int start, int end) {
103+
return new Traversal(array, start, end);
104+
}
105+
106+
public int getFirst() {
107+
return array[start];
108+
}
109+
110+
public Traversal(int start, int end) {
111+
this.start = start;
112+
this.end = end;
113+
}
114+
115+
@Override
116+
public String toString() {
117+
return "{" +
118+
"start=" + start +
119+
", end=" + end +
120+
'}';
121+
}
122+
}
123+
```
124+
125+
### TC, SC
126+
127+
시간 복잡도는 O(n)이고, 공간 복잡도는 O(n)이다.

‎_posts/2024-06-23-leetcode-208.md

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
---
2+
layout: post
3+
title: (Leetcode) 208 - Implement Trie (Prefix Tree)
4+
categories: [스터디-알고리즘]
5+
tags: [자바, java, 리트코드, Leetcode, 알고리즘, trie, tree, prefix]
6+
date: 2024-06-23 09:30:00 +0900
7+
toc: true
8+
---
9+
10+
기회가 되어 [달레님의 스터디](https://github.com/DaleStudy/leetcode-study)에 참여하여 시간이 될 때마다 한문제씩 풀어보고 있다.
11+
12+
[https://neetcode.io/practice](https://neetcode.io/practice)
13+
14+
---
15+
16+
[https://leetcode.com/problems/implement-trie-prefix-tree/](https://leetcode.com/problems/implement-trie-prefix-tree/)
17+
18+
```java
19+
class Trie {
20+
21+
Node root = new Node();
22+
23+
public Trie() {
24+
25+
}
26+
27+
public void insert(String word) {
28+
Node currentNode = root;
29+
for(char c : word.toCharArray()) {
30+
if(currentNode.nodes[c - 97] == null) {
31+
currentNode.nodes[c - 97] = new Node();
32+
}
33+
currentNode = currentNode.nodes[c - 97];
34+
}
35+
currentNode.val = word;
36+
}
37+
38+
public boolean search(String word) {
39+
Node currentNode = root;
40+
for(char c : word.toCharArray()) {
41+
if(currentNode.nodes[c - 97] == null) {
42+
return false;
43+
}
44+
currentNode = currentNode.nodes[c - 97];
45+
}
46+
47+
return currentNode.val != null && currentNode.val.equals(word);
48+
}
49+
50+
public boolean startsWith(String prefix) {
51+
Node currentNode = root;
52+
for(char c : prefix.toCharArray()) {
53+
if(currentNode.nodes[c - 97] == null) {
54+
return false;
55+
}
56+
currentNode = currentNode.nodes[c - 97];
57+
}
58+
return true;
59+
}
60+
}
61+
62+
class Node {
63+
String val;
64+
Node[] nodes = new Node[26];
65+
}
66+
```
67+
68+
### TC, SC
69+
70+
insert, search, startsWith 메소드의 경우 입력된 문자열의 길이를 n 이라 하였을 때 시간 복잡도는 `O(n)`이다. 공간 복잡도는 `insert된 문자열의 갯수` 를 `N` 이라 하고 `insert된 문자열의 길이의 평균` 를 `L`이라고 하였을 때 `O(N * L * 26)`이다. 26은 계수이기 때문에 생략할 수 있다.

‎_posts/2024-06-23-leetcode-230.md

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
---
2+
layout: post
3+
title: (Leetcode) 230 - Kth Smallest Element in a BST
4+
categories: [스터디-알고리즘]
5+
tags: [자바, java, 리트코드, Leetcode, 알고리즘, tree, dfs, reference]
6+
date: 2024-06-23 09:30:00 +0900
7+
toc: true
8+
---
9+
10+
기회가 되어 [달레님의 스터디](https://github.com/DaleStudy/leetcode-study)에 참여하여 시간이 될 때마다 한문제씩 풀어보고 있다.
11+
12+
[https://neetcode.io/practice](https://neetcode.io/practice)
13+
14+
---
15+
16+
[https://leetcode.com/problems/kth-smallest-element-in-a-bst/](https://leetcode.com/problems/kth-smallest-element-in-a-bst/)
17+
18+
```java
19+
class Solution {
20+
public int kthSmallest(TreeNode root, int k) {
21+
return dfs(root, new Holder(k));
22+
}
23+
24+
public int dfs(TreeNode root, Holder holder) {
25+
if(root.left != null) {
26+
int left = dfs(root.left, holder);
27+
if (left != -1) {
28+
return left;
29+
}
30+
}
31+
holder.decrease();
32+
if (holder.k == 0) {
33+
return root.val;
34+
}
35+
if(root.right != null) {
36+
int right = dfs(root.right, holder);
37+
if (right != -1) {
38+
return right;
39+
}
40+
}
41+
return -1;
42+
}
43+
}
44+
45+
class Holder {
46+
int k;
47+
48+
public Holder(int k) {
49+
this.k = k;
50+
}
51+
52+
public void decrease() {
53+
this.k = this.k - 1;
54+
}
55+
}
56+
```
57+
58+
Holder 라는 객체를 만든 이유는 k의 값을 int 값으로 전달하는 것이 아닌 reference 타입으로 전달 되게 하여 dfs 과정중 모든 스택에서 동일한 값을 바라볼 수 있도록 하기 위함이다.
59+
60+
### TC, SC
61+
62+
시간 복잡도는 O(n)이고, 공간 복잡도는 O(n)이다. 트리가 균등할 경우 O(logn)에 가까워진다.

‎_posts/2024-06-23-leetcode-39.md

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
1+
---
2+
layout: post
3+
title: (Leetcode) 39 - Combination Sum
4+
categories: [스터디-알고리즘]
5+
tags: [자바, java, 리트코드, Leetcode, 알고리즘, array, bfs, tree, backtracking]
6+
date: 2024-06-23 09:30:00 +0900
7+
toc: true
8+
---
9+
10+
기회가 되어 [달레님의 스터디](https://github.com/DaleStudy/leetcode-study)에 참여하여 시간이 될 때마다 한문제씩 풀어보고 있다.
11+
12+
[https://neetcode.io/practice](https://neetcode.io/practice)
13+
14+
---
15+
16+
[https://leetcode.com/problems/combination-sum/](https://leetcode.com/problems/combination-sum/)
17+
18+
## 내가 작성한 풀이
19+
20+
### bfs 로 풀기
21+
22+
```java
23+
class Solution {
24+
public List<List<Integer>> combinationSum(int[] candidates, int target) {
25+
Arrays.sort(candidates);
26+
List<List<Integer>> result = new ArrayList<>();
27+
28+
Queue<Holder> queue = new LinkedList<>();
29+
queue.offer(new Holder(target));
30+
31+
while (!queue.isEmpty()) {
32+
Holder holder = queue.poll();
33+
int lastInput = !holder.combination.isEmpty() ? holder.combination.get(holder.combination.size() - 1) : 0;
34+
int left = holder.left;
35+
if (left == 0) {
36+
result.add(holder.combination);
37+
continue;
38+
}
39+
40+
for (int candidate : candidates) {
41+
if (candidate < lastInput) {
42+
continue;
43+
}
44+
45+
if (left - candidate >= 0) {
46+
queue.add(holder.next(candidate));
47+
} else {
48+
break;
49+
}
50+
}
51+
}
52+
53+
return result;
54+
}
55+
}
56+
57+
class Holder {
58+
int left;
59+
List<Integer> combination;
60+
61+
public Holder(int left) {
62+
this.left = left;
63+
this.combination = new ArrayList<>();
64+
}
65+
66+
private Holder(int left, List<Integer> combination) {
67+
this.left = left;
68+
this.combination = combination;
69+
}
70+
71+
public Holder next(int minus) {
72+
List<Integer> combinedList = new ArrayList<>(this.combination.size() + 1);
73+
combinedList.addAll(this.combination);
74+
combinedList.add(minus);
75+
return new Holder(this.left - minus, combinedList);
76+
}
77+
78+
@Override
79+
public String toString() {
80+
return "{" +
81+
"left=" + left +
82+
", combination=" + combination +
83+
'}';
84+
}
85+
}
86+
```
87+
88+
#### TC, SC
89+
90+
시간 복잡도는 `O(2^n)`이고, 공간 복잡도는 `O(2^n)`이다.
91+
92+
### backtracking 으로 풀기
93+
94+
TODO:

0 commit comments

Comments
 (0)