-
[Data Structure] Java ์ด์งํธ๋ฆฌ(Binary Tree) ๊ตฌํData Structure 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); } }
๋ฐ์ํ'Data Structure' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Data Structure] Deque ์ฌ์ฉ๋ฒ (0) 2021.08.01 [Data Structure] Java ํ(Queue) ์ฌ์ฉ (0) 2021.01.15 [Data Structure] Java ์คํ(Stack) ์ฌ์ฉ (0) 2021.01.15 [Data Structure] Java ๋งํฌ๋ ๋ฆฌ์คํธ(LinkedList) ๊ตฌํ (0) 2021.01.15 [Data Structure] multimap ์ฌ์ฉ๋ฒ (0) 2020.11.08