๋ฐ์ํ
์ด์งํ์ ํธ๋ฆฌ ๊ตฌ์กฐ
์ด์งํ์ ํธ๋ฆฌ์ ์กฐ๊ฑด (์ด์ง ํธ๋ฆฌ์ ๋ค๋ฅด๋ค)
- ๋ชจ๋ ์์๋ ์ค๋ณต๋ ๊ฐ์ ๊ฐ์ง๋ฉด ์๋๋ค.
- ํธ๋ฆฌ์ ๋ฃจํธ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ์ ์กด์ฌํ๋ ๋ ธ๋๋ค์ ๊ฐ์ ๋ฃจํธ์ ๊ฐ๋ณด๋ค ์์์ผ ํ๋ค.
- ๋ฐ๋๋ก ์ค๋ฅธ์ชฝ์ ์กด์ฌํ๋ ๋ ธ๋๋ค์ ๊ฐ์ ๋ฃจํธ์ ๊ฐ๋ณด๋ค ์ปค์ผ ํ๋ค.
์ด์งํ์ ํธ๋ฆฌ์ ์ฝ์
์์ ์ด์งํธ๋ฆฌ์ ์กฐ๊ฑด์ ์ด์ฉํด์ ์ฝ์ ์ ์ ๊ทธ๋ฆผ ์ฒ๋ผ ํด์ฃผ๋ฉด ๋๋ค.
์ฝ์ ์ฝ๋๋ฅผ ์์ฑํด ๋ณด๋ฉด,
public class BinaryTree {
Node root;
public void insertNode(int value) {
/* root๊ฐ ๋น์์ ๊ฒฝ์ฐ */
if(root == null){
root = new Node(value);
}else {
Node temp = this.root;
while(true) {
/* ์ผ์ชฝ์ผ๋ก ๊ฐ์ผ ํ๋ ๊ฒฝ์ฐ */
if(temp.value > value){
if(temp.left != null){
temp.left = new Node(value);
break;
}
temp = temp.left;
}
/* ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ์ผ ํ๋ ๊ฒฝ์ฐ */
else {
if(temp.right != null){
temp.right = new Node(value);
break;
}
temp = temp.right;
}
}
}
}
}
์ด์งํ์ ํธ๋ฆฌ์ ์ํ ๋ฐฉ๋ฒ
- ์ ์์ํ (Pre-order)
- ๋ฃจํธ -> ์ผ์ชฝ - > ์ค๋ฅธ์ชฝ
/* Pre-order (root - left - right) */
public void preOrderSearch(Node node) {
if(node != null) {
System.out.println(node.value + " -> ");
preOrderSearch(node.left);
preOrderSearch(node.right);
}
}
A -> B -> D -> E -> C -> F -> G
- ์ค์์ํ (In-order)
- ์ผ์ชฝ -> ๋ฃจํธ -> ์ค๋ฅธ์ชฝ
/* In-order (left - root - right) */
public void inOrderSearch(Node node) {
if(node != null) {
inOrderSearch(node.left);
System.out.println(node.value + " -> ");
inOrderSearch(node.right);
}
}
D -> B -> E -> A -> F -> C -> G
- ํ์์ํ (Post-order)
- ์ผ์ชฝ -> ์ค๋ฅธ์ชฝ - > ๋ฃจํธ
/* Post-order (left - right - root) */
public void postOrderSearch(Node node) {
if(node != null) {
postOrderSearch(node.left);
postOrderSearch(node.right);
System.out.println(node.value + " -> ");
}
}
D -> E -> B -> F -> G -> C -> A
BFS - ๋๋น ์ฐ์ ํ์, DFS - ๊น์ด ์ฐ์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ ํด๋น ํฌ์คํธ๋ฅผ ์ฐธ๊ณ ํ์๊ธธ ๋ฐ๋๋๋ค.
References
๋ฐ์ํ