Data Structure
[Data Structure] Java ์ด์งํธ๋ฆฌ(Binary Tree) ๊ตฌํ
An effort will never betray ๐
2021. 1. 17. 21:07
๋ฐ์ํ
- ์ด ๊ธ์ "์จ๋ผ์ธ ์๋ฐ ์คํฐ๋ ๋ด์ฉ"์ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
์ด์งํธ๋ฆฌ(Binary Tree)๋?
ํธ๋ฆฌ๋ ๋ ธ๋์ ๊ฐ์ ์ผ๋ก ์ด๋ฃจ์ด์ ธ ๋ฐ๋ณต์ ์ผ๋ก ์ ์๋๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
์ด์ง ํธ๋ฆฌ๋ ํธ๋ฆฌ์ ์ข ๋ฅ ์ค ํ๋๋ก ๋ชจ๋ ๋ ธ๋๊ฐ ๋ ๊ฐ์ ์๋ธํธ๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ์๋ ํธ๋ฆฌ์ ๋๋ค.
์ด์ง ํธ๋ฆฌ์ ์๋ธ ํธ๋ฆฌ๋ ๊ณต๋ฐฑ์ด ๋ ์๋ ์๊ณ ํ๋์ ์๋ธํธ๋ฆฌ๋ง ๊ฐ์ง๊ฑฐ๋ ๋ ๊ฐ ๋ชจ๋ ๊ฐ์ง ์๋ ์์ต๋๋ค.
์ด์งํธ๋ฆฌ ๊ตฌํ
๋ ธ๋ ํด๋์ค
public class Node {
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
left = null;
right = null;
}
}
๋จผ์ ์ด์งํธ๋ฆฌ๋ฅผ ๊ตฌํํ๊ธฐ ์ ์ ์ด์งํธ๋ฆฌ์ ํ์ํ ๋ ธ๋๋ฅผ ํด๋์ค๋ก ํํํด์ผ ํฉ๋๋ค. ์ด ๋ ๋ ธ๋ ๋ด์ ๋ด์ ๋ฐ์ดํฐ์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ, ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํฌ ํฌ์ธํฐ๋ฅผ ๊ฐ์ ธ์ผ ํฉ๋๋ค.
์ด์งํธ๋ฆฌ ํด๋์ค
- void push(Node node) : ๋ ธ๋๋ฅผ ํธ๋ฆฌ์ ์ถ๊ฐํ๋ ํจ์
- int pop(Node node) : ๋ ธ๋๋ฅผ ํธ๋ฆฌ์์ ์ ๊ฑฐํ๋ ํจ์
- boolean contain(Node node) : ๋ ธ๋๊ฐ ํธ๋ฆฌ์ ์๋์ง ํ์ธํ๋ ํจ์
- Node removeLastNode(Node node) : ํธ๋ฆฌ์์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ ํจ์
- boolean isSame(Node a, Node b) : ๋ ๊ฐ์ ๋ ธ๋๊ฐ ๊ฐ์ ๋ ธ๋์ธ์ง ํ์ธํ๋ ํจ์
BFS (Breadth-First Search)๋?
- BFS๋ ๊ทธ๋ํ ์ ์ฒด๋ฅผ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก ๋ฃจํธ ๋ ธ๋์์๋ถํฐ ์์ํ์ฌ ๊ฐ๊น์ด ๋ ธ๋๋ถํฐ ๋จผ์ ํ์ํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
- ๋ฃจํธ๋ ธ๋๋ถํฐ ๊ฐ๊น์ด ์ ์ ์ ๋ฐฉ๋ฌธํ๊ณ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๋ ๋ ธ๋๋ ์๋์ ์ผ๋ก ๋์ค์ ๋ฐฉ๋ฌธํจ์ผ๋ก์จ ๋ ธ๋๋ฅผ ๋๊ฒ ํ์ํฉ๋๋ค.
- BFS ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ์ ํ(Queue) ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํฉ๋๋ค.
public void printBFS(Node node) {
Queue<Node> queue = new LinkedList<Node>();
queue.add(node);
while (!queue.isEmpty()) {
Node temp = queue.poll();
System.out.println(temp.value);
if (temp.left != null) {
queue.add(temp.left);
}
if (temp.right != null) {
queue.add(temp.right);
}
}
}
DFS(Depth-First Search)๋?
- DFS๋ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ทธ๋ํ ์ ์ฒด๋ฅผ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ฃจํธ๋ ธ๋์์ ํ๋์ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๊ฒ ๋๋ฉด ๋ค์ ์ธ์ ํ ๋ ธ๋๋ก ๊ฐ๊ธฐ ์ ์ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ฅผ ๋๊น์ง ํ์ํ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
- ํ๋์ ๋ ธ๋๋ฅผ ๋๊น์ง ๋ฐฉ๋ฌธํ๊ธฐ ๋๋ฌธ์ ๋ ธ๋๋ฅผ ๊น๊ฒ ํ์ํ๋ค๊ณ ๋ณผ ์ ์์ต๋๋ค.
- DFS ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ์ ์ฌ๊ทํจ์ ๋๋ ์คํ์ ์ด์ฉํ์ฌ ๊ตฌํํฉ๋๋ค.
public void printDFS(Node node) {
if(node.left == null && node.right == null){
System.out.println(node.value);
}else{
if(node.left != null){
printDFS(node.left);
}
System.out.println(node.value);
if(node.right != null){
printDFS(node.right);
}
}
}
๊ฒฐ๊ณผ
public class Main {
public static void main(String[] args) {
BinaryTree bt = new BinaryTree();
Node node = new Node(3);
Node node1 = new Node(5);
Node node2 = new Node(7);
Node node3 = new Node(4);
Node node4 = new Node(2);
bt.push(node);
bt.push(node1);
bt.push(node2);
bt.push(node3);
bt.push(node4);
System.out.println("BFS๋ก ํ์ํฉ๋๋ค");
bt.printBFS(node);
System.out.println("\nDFS๋ก ํ์ํฉ๋๋ค");
bt.printDFS(node);
}
}
๋ฐ์ํ