Tags
- Java
- Dynamic Programming
- ๊น์ด ์ฐ์ ํ์
- ๊ต์ฌ
- ๋ฐฑํธ๋ํน
- ์๋ฃ๊ตฌ์กฐ
- ๊ทธ๋ํ ํ์
- DP
- greedy
- BOJ
- ๋ฌธ์์ด
- ์ ๋ ฌ
- Python
- Study
- BFS
- PGM
- SpringBoot
- ๋๋น ์ฐ์ ํ์
- dfs
- ๊ตฌํ
- Brute Force Algorithm
- ์ํ
- ์ ์๋ก
- sort
- queue
- CodingTest
- LV2
- ์๋ฎฌ๋ ์ด์
- ๊ทธ๋ํ ์ด๋ก
- stack
Archives
๊ธฐ๋ก๋ฐฉ
BOJ_5639 : ์ด์ง ๊ฒ์ ํธ๋ฆฌ ๋ณธ๋ฌธ
๐ธ ๋ฌธ์ ๋ถ์ ๐ธ
- ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ์ ์ ์ํ ๊ฒฐ๊ณผ๋ฅผ ํ ๋๋ก ํ์ ์ํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
๐ธ ๋ฌธ์ ํ์ด ๐ธ
- ์ ์ ์ํ ๊ฒฐ๊ณผ๋ฅผ EOF(End Of File : null)๊ฐ ๋์ฌ ๋๊น์ง ์
๋ ฅ๋ฐ๋๋ค.
- ์ฒซ ๋ฒ์งธ ๊ฒฐ๊ณผ๋ Root ๋ก ์ฌ์ฉํ๋ค.
- ์ดํ ๊ฒฐ๊ณผ๋ ์์ผ๋ฉด ์ผ์ชฝ ์์ ๋ ธ๋, ํฌ๋ฉด ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ก ๊ตฌ๋ถํด ์ฌ๊ท ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ ์ ์ฅํ๋ค.
- ์ ์ ์ํ ๊ฒฐ๊ณผ๋ก ๋ง๋ค์ด์ง ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ํ์ ์ํ ๋ฐฉ์์ผ๋ก ์ฌํ์ํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
- ์ ์ ์ํ์ ๋น์ทํ์ง๋ง, ํ์ ์์๋ง ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
๐ธ ์ฝ๋ ๐ธ
import java.io.*;
public class Main {
private static class Node {
private final int root;
private Node left;
private Node right;
public Node(int root) {
this.root = root;
}
public int getRoot() {
return root;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
}
public static void main(String[] args) throws IOException {
// Input
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
Node root = new Node(Integer.parseInt(br.readLine()));
String str = null;
// Pre Order
while ((str = br.readLine()) != null) {
make_tree(root, Integer.parseInt(str));
}
// Post Order
StringBuilder sb = new StringBuilder();
travel_tree(root, sb);
// Output
bw.write(sb.toString());
bw.flush();
}
private static void make_tree(Node node, int num) { // Pre order
if (node.getRoot() > num) { // left
if (node.getLeft() == null) {
node.setLeft(new Node(num));
} else {
make_tree(node.getLeft(), num);
}
} else { // right
if (node.getRight() == null) {
node.setRight(new Node(num));
} else {
make_tree(node.getRight(), num);
}
}
}
private static void travel_tree(Node node, StringBuilder sb) { // Post order
// left
if (node.getLeft() != null) {
travel_tree(node.getLeft(), sb);
}
// right
if (node.getRight() != null) {
travel_tree(node.getRight(), sb);
}
// root
sb.append(node.getRoot()).append('\n');
}
}
๐ธ ์ฝ๋ ํด์ ๐ธ
- ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด Node ํด๋์ค๋ฅผ ๋ง๋ค์ด ์ฌ์ฉํ๋ค.
- ํ์ฌ ๋ ธ๋ ๊ฐ์ธ intํ ๋ณ์ root์ ์ผ์ชฝ ์์, ์ค๋ฅธ์ชฝ ์์์ ์ ์ฅํ Node ๊ฐ์ฒด left, right๋ฅผ ์ฌ์ฉํ๋ค.
- getter, setter๋ฅผ ์ฌ์ฉํด๋ณด์๋ค.
- ์ ์ ์ํ ๊ฒฐ๊ณผ๋ฅผ ํ ๋๋ก ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ์์ฑํ๋ค.
- ์ฒซ ๊ฒฐ๊ณผ ๊ฐ์ Node ๊ฐ์ฒด root๋ก ์ ์ฅํด ํ์์ ์์ ํ ๋๋ง๋ค ์ฌ์ฉํ๋ค.
- ๋ค์ ๊ฒฐ๊ณผ ๊ฐ ๋ถํฐ๋ make_tree() ๋ฉ์๋๋ฅผ ํธ์ถํด Node์ root ๊ฐ๋ณด๋ค ์์ผ๋ฉด left, ํฌ๋ฉด right๋ก ์ ์ฅํ๋ค.
- left, right ๊ฐ์ฒด๊ฐ ์์ฑ ๋์ง ์์ null์ด๋ผ๋ฉด ํ์์ ์ข ๋ฃํ๊ณ ํด๋น Node ๊ฐ์ฒด๋ฅผ ์์ฑํด ์ ์ฅํ๋ค.
- ํ์ ์ํ๋ ์์ root ๋
ธ๋๋ถํฐ left, right, root๊ฐ ์์ผ๋ก ํ์ํด StringBuilder์ ์ ์ฅํ๋ค.
- travel_tree() ๋ฉ์๋์ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ํ์ํ๋ค.
- ์ต์ข ํ์ ๊ฒฐ๊ณผ์ธ StringBuilder๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ธ end ๐ธ
- ์ค๋๋ง์ ๋ค์ ์์ํ๋ ๋ฐฑ์ค ์ฝํ
ํ์ด์ธ๋ฐ ๊ณจ๋๋ง ํ ๊ณํ์ด๊ณ , ์คํธ๋ฆญ์ ์ด์ด๋๊ฐ ๋ณผ ์๊ฐ์ด๋ค.
- Solved.ac์ Class ๋ฌธ์ ๋ ํ๋ฉด์, ์ฝํ ๊ต์ฌ ๋ฌธ์ ๋ ๋ฐ๋ผ ํ ์๊ฐ์ด๊ณ , ์๊ณ ๋ฆฌ์ฆ๋ง๋ค ๋ํ ๋ฌธ์ ๋ค์ ์ ์ ํด๋์ ๊ฐ์ ๋ฌธ์ ๋ฅผ ๋ฐ๋ณต์ผ๋ก ํธ๋ ์ฐ์ต๋ ํด๋ณผ ์๊ฐ์ด๋ค.
- ์ ๋ฌธ์ ๋ Node ํด๋์ค์ ์ฌ๊ท ๋ฉ์๋๋ง ๊ตฌํํ ์ค ์๋ฉด ๊ฐ๋จํ ํ์ดํ ์ ์๋ ๊ฒ ๊ฐ๋ค.
728x90
'CodingTest > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ_1517 : ๋ฒ๋ธ ์ํธ (0) | 2024.01.26 |
---|---|
BOJ_2638 : ์น์ฆ (0) | 2024.01.25 |
Lv.2 : ์ฐ์๋ ๋ถ๋ถ ์์ด์ ํฉ (0) | 2023.11.30 |
Lv.2 : ์๊ฒฉ ์์คํ (0) | 2023.11.29 |
Lv.2 : ์ซ์ ๋ณํํ๊ธฐ (0) | 2023.11.27 |