5/18 ์งํํ๋ ์ค์ํํธ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์๊ณ ๋ฆฌ์ฆ ์ฑ ์ 5์ฅ 'ํธ๋ฆฌ ๊ตฌ์กฐ ๊ธฐ๋ฐ์ ์๊ณ ๋ฆฌ์ฆ' ์คํฐ๋ ์ ๋ฆฌ์ ๋๋ค!
๐
1. ํธ๋ฆฌ์ ํน์ง
2. ํธ๋ฆฌ vs ๊ทธ๋ํ
3. ์ด์ง ํธ๋ฆฌ, ์ด์ง ํธ๋ฆฌ์ ์ข ๋ฅ
4. ์ด์ง ํ์ ํธ๋ฆฌ(BST, Binary Search Tree)
5. ํธ๋ฆฌ ์ํ ๋ฐฉ์
6. B ํธ๋ฆฌ์ ์คํ๋ ์ด ํธ๋ฆฌ
๐ ํธ๋ฆฌ(Tree)
ํธ๋ฆฌ๋ ๋ ธ๋์ ์งํฉ์ผ๋ก, ๊ณ์ธต์ ์ด๋ฃจ๊ณ ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
ํธ๋ฆฌ์ ์ต์์ ๋ ธ๋์ธ ๋ฃจํธ ๋ ธ๋, ๊ทธ ์๋๋ก ๋ป์ด๋๊ฐ๋ ์์ ๋ ธ๋๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
๊ฐ๊ฐ์ ๋ ธ๋๋ ํค ๊ฐ, ์์ ๋ ธ๋ ์งํฉ, ๋ถ๋ชจ ๋ ธ๋ ๋งํฌ ๋ฑ์ ํฌํจํ๊ณ ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋๋ค.
ํธ๋ฆฌ์ ํน์ง
ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ํ ์ข ๋ฅ๋ก, ์ฌ์ดํด์ด ์๋ ํ๋์ ์ฐ๊ฒฐ ๊ทธ๋ํ์ ๋๋ค.
ํธ๋ฆฌ๋ ์ด์ง ํธ๋ฆฌ, ์ด์ง ํ์ ํธ๋ฆฌ, ๊ท ํ ํธ๋ฆฌ(AVL ํธ๋ฆฌ, red-black ํธ๋ฆฌ), ์ด์ง ํ(์ต๋ํ, ์ต์ํ) ๋ฑ์ด ์์ต๋๋ค.
ํธ๋ฆฌ์ ์ํ ๋ฐฉ์์ Pre-order, In-order, Post-order ๋ก ์ด๋ฃจ์ด์ง๋๋ค.
๐ ํธ๋ฆฌ(Tree) vs ๊ทธ๋ํ(Graph)
๊ทธ๋ํ๋ ๊ผญ์ง์ (Vertex, ๋ ธ๋)๊ณผ ๋ชจ์๋ฆฌ(Edge)์ ์งํฉ์ผ๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋๋ค.
ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ํ ์ข ๋ฅ๋ก, ์ฌ์ดํด์ด ์๋ ํ๋์ ์ฐ๊ฒฐ ๊ทธ๋ํ์ ๋๋ค.
์ฌ์ดํด์ด ์๋ค๋ ๊ฒ์ ๊ฐ์ ๋ ธ๋๋ฅผ ์ํํ์ง ์๋๋ค๋ ๋ป์ ๋๋ค. ๋ ๋ ธ๋ ์ฌ์ด์ ๊ฒฝ๋ก๊ฐ ํ๋์ ๋๋ค.
โ๏ธ ์ด์ง ํธ๋ฆฌ(Binary Tree)
์ด์ง ํธ๋ฆฌ๋ ๊ฐ ๋ ธ๋๊ฐ ์ต๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ง ์ง๋ ์ ์๋ ํธ๋ฆฌ์ ๋๋ค.
1) ํ ์ด์ง ํธ๋ฆฌ(Full binary tree)
๊ฐ ๋ ธ๋๊ฐ 0 or 2๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ๋ ํธ๋ฆฌ์ ๋๋ค.
2) ์์ ์ด์ง ํธ๋ฆฌ(Complete binary tree)
๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ ๋ชจ๋ ๋ ๋ฒจ์ด ๋ ธ๋๋ก ์์ ํ๊ฒ ์ฑ์์ง ์ํ์ ๋๋ค. ๋ง์ง๋ง ๋ ๋ฒจ์ ๋ ธ๋๋ ์ข์ธก๋ถํฐ ์ฑ์์ ธ์ผ ํฉ๋๋ค.
3) ํผํํธ ์ด์ง ํธ๋ฆฌ(Perfect binary tree)
๋ชจ๋ ๋ด๋ถ ๋ ธ๋๊ฐ 2๊ฐ์ ์์ ๋ ธ๋๋ฅผ ์ง๋๋ฉฐ, ๋ชจ๋ ์ ๋ ธ๋๊ฐ ๋์ผํ ๊น์ด๋ฅผ ๊ฐ์ง๋ ํธ๋ฆฌ์ ๋๋ค.
4) ๊ท ํ ์ด์ง ํธ๋ฆฌ(Balanced binary tree)
(๋ ธ๋์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ผ์ด๋๋ ๊ฒฝ์ฐ) ์ ๋ ธ๋๊น์ง ์ด์ด์ง๊ธฐ ์ํ ๋์ด๋ฅผ ์๊ฒ ์ ์งํ๋๋ก ํ๋ ํธ๋ฆฌ์ ๋๋ค.
๐ก ๊ท ํ ์ด์ง ํธ๋ฆฌ(Balanced binary tree) ๊ฐ ์ค์ํ ์ด์
์ด์ง ํธ๋ฆฌ๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๊ธฐ๋ฐ์ด๊ณ , ์ด์ง ํ์ ํธ๋ฆฌ์์ L < P, R >= P ๊ท์น์ ์ง์ผ์ผํ๊ธฐ ๋๋ฌธ์ 1~4 ์์๋๋ก ์ฝ์ ํ๋ฉด ํธํฅ๋ ์ด์ง ํธ๋ฆฌ(Skewed Binary Tree)๊ฐ ๋ฉ๋๋ค. ์ด ๊ฒฝ์ฐ ํธ๋ฆฌ์ ๋์ด๊ฐ ์ปค์ง๊ฒ ๋๊ณ , 4๋ฅผ ์ฐพ๊ธฐ ์ํด์๋ 4๋ฒ์ ํ์์ด ํ์ํฉ๋๋ค. ์ฆ, ์๊ฐ ๋ณต์ก๋๋ O(n) ์ด ๋ฉ๋๋ค.
์ด๋ฌํ ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ํผํ๊ธฐ ์ํด ๊ท ํ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ด์ฉํฉ๋๋ค. ๋ ธ๋์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ผ์ด๋๋ ๊ฒฝ์ฐ, ๋์ด๊ฐ ์ต์๊ฐ ๋๋๋ก ์ ์งํ๋ ๊ฒ์ ๋๋ค. ์ด ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋ O(logn) ์ ๋๋ค. ๋ํ์ ์ธ ๊ท ํ ์ด์ง ํ์ ํธ๋ฆฌ๋ AVL ํธ๋ฆฌ, ๋ ๋-๋ธ๋ํธ๋ฆฌ๊ฐ ์์ต๋๋ค.
โ๏ธ ์ด์ง ํ์ ํธ๋ฆฌ(BST, Binary Search Tree)
์ด์ง ํ์ ํธ๋ฆฌ๋ ๋ ธ๋ P ๊ฐ ๋ค์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํธ๋ฆฌ์ ๋๋ค. ์ฆ, ํ์ฌ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ข์ธก์ ํ์ฌ ๋ ธ๋๋ณด๋ค ์์ ๊ฐ, ์ฐ์ธก์ ํ์ฌ ๋ ธ๋๋ณด๋ค ํฐ ๊ฐ์ด์ด์ผ ํฉ๋๋ค.
1. ์ข์ธก ์๋ธํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋ L.value < P.value
2. ์ฐ์ธก ์๋ธํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋ R.value >= P.value
์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ์ด์ง ํธ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ฐ์ดํฐ ์ ๊ทผ, ๊ฒ์, ์ฝ์ , ์ญ์ ๋ฑ์ ์ํํฉ๋๋ค. ์๊ฐ๋ณต์ก๋๋ O(n) ~ O(logn) ์ผ๋ก ํธ๋ฆฌ์ ๋์ด์ ์ํฅ์ ๋ฐ์ต๋๋ค. ์ด ๋, n ๊ฐ์ ๋ ธ๋๋ฅผ ์ง๋ ์์ ์ด์ง ํธ๋ฆฌ์ ๊ฒฝ์ฐ, O(logn) ์ ์๊ฐ ๋ณต์ก๋. ํธํฅ๋ ์ด์ง ํธ๋ฆฌ (์ฐ๊ฒฐ ๋ชฉ๋ก)์ผ๋ก ๊ตฌ์ฑ๋ ๊ฒฝ์ฐ O(n) ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค.
โ๏ธ ์ด์ง ํ์ ํธ๋ฆฌ ์ํ ๋ฐฉ์
ํธ๋ฆฌ๋ฅผ ์ํํ ๋ ํน์ ํ ์์์ ๋ฐ๋ผ ๊ฐ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํฉ๋๋ค.
1) ์ค์ ์ํ(In-order tree walk, in-order traversal)
"์ข์ธก ์๋ธํธ๋ฆฌ -> ๋ฃจํธ ๋ ธ๋ ๊ฐ -> ์ฐ์ธก ์๋ธํธ๋ฆฌ" ์์์ ๋ฐ๋ผ ๊ฐ๊ฐ์ ์๋ธํธ๋ฆฌ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํฉ๋๋ค.์ด์ง ํ์ ํธ๋ฆฌ์ ๋ ธ๋ ๊ฐ์ "์ข์ธก ๊ฐ < ๋ฃจํธ ๋ ธ๋ ๊ฐ < ์ฐ์ธก ๊ฐ" ์ด๋ฏ๋ก, ๋ ธ๋์ ๊ฐ์ด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ์ํ์ค๊ฐ ๋ฐํ๋ฉ๋๋ค.
func traverseInOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
BinaryTreeNode.traverseInOrder(node: node.leftChild)
print(node.value)
BinaryTreeNode.traverseInOrder(node: node.rightChild)
}
2) ์ ์ ์ํ(Pre-order tree walk)
"๋ฃจํธ ๋ ธ๋ ๊ฐ -> ์ข์ธก ์๋ธํธ๋ฆฌ -> ์ฐ์ธก ์๋ธํธ๋ฆฌ" ์์์ ๋ฐ๋ผ ๊ฐ๊ฐ์ ์๋ธํธ๋ฆฌ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํฉ๋๋ค.
BST ๋ ธ๋๋ฅผ ์ฐจ๋ก๋๋ก ๋ณต์ฌํ ๋ ์ ์ฉํฉ๋๋ค.
func traversePreOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
print(node.value)
BinaryTreeNode.traversePreOrder(node: node.leftChild)
BinaryTreeNode.traversePreOrder(node: node.rightChild)
}
3) ํ์ ์ํ(Post-order tree walk)
"์ข์ธก ์๋ธํธ๋ฆฌ → ์ฐ์ธก ์๋ธํธ๋ฆฌ → ๋ฃจํธ ๋ ธ๋" ์์์ ๋ฐ๋ผ ๊ฐ๊ฐ์ ์๋ธํธ๋ฆฌ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํฉ๋๋ค.
์ข์ธก ํ๋จ์์ ์์ํด ์ฐ์ธก ์๋จ์ผ๋ก ์ด๋ํด ์ฌ๋ผ๊ฐ๋ฉด์ ๋ ธ๋๋ฅผ ์ถ๋ ฅํฉ๋๋ค. ์ญ์ ์์ ์ ํ ๋ ์ ์ฉํฉ๋๋ค.
func traversePostOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
BinaryTreeNode.traversePostOrder(node: node.leftChild)
BinaryTreeNode.traversePostOrder(node: node.rightChild)
print(node.value)
}
โ๏ธ B ํธ๋ฆฌ
์ด์ง ํ์ ํธ๋ฆฌ(BST)์ ๋น์ทํ์ง๋ง, ๋ ๊ฐ์ง ์ฐจ์ด์ ์ด ์์ต๋๋ค.
1. ์์ ๋ ธ๋์ ์๊ฐ 2๊ฐ๋ก ํ์ ๋์ง ์์ต๋๋ค.
2. ๋ ธ๋๊ฐ ์ง๋ key ๋ฐ์ดํฐ ์ญ์ 1๊ฐ๋ก ํ์ ๋์ง ์์ต๋๋ค.
B ํธ๋ฆฌ๋ ์ค์ค๋ก ๊ท ํ์ ์ก๊ณ , ์ค์ค๋ก ์ ๋ ฌ, ๋ฃจํธ ๋ ธ๋๋ฅผ ์ค์ค๋ก ์ค์ ํ๋ ํธ๋ฆฌ์ ๋๋ค. ๊ท ํ์ด ์กํ์๊ธฐ ๋๋ฌธ์ O(logn) ๋ด์ ๋ ธ๋์ ์ฝ์ , ๊ฒ์, ์ญ์ , ์ ๊ทผ์ด ๊ฐ๋ฅํฉ๋๋ค.
๋ฐ์ดํฐ๋ฒ ์ด์ค์ ํ์ผ์์คํ ์์ ๋ง์ด ์ฌ์ฉ๋๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
โ๏ธ ์คํ๋ ์ด ํธ๋ฆฌ (Splay tree)
์ด์ง ํ์ ํธ๋ฆฌ(BST)์ ํน์ํ ํํ๋ก ์ต๊ทผ์ ์ ๊ทผํ ๋ ธ๋๊ฐ ํธ๋ฆฌ์ ์์๋ก ์ด๋ํ๋ ํธ๋ฆฌ์ ๋๋ค. ๋ ธ๋์ ๋ํ ์ ๊ทผ์ด ๋งค์ฐ ๋น๋ฒํ ์ํ์์ ์ต๊ทผ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ฅผ ๊ณจ๋ผ๋ผ ์ ์์ด, ๋ ธ๋ ๊ฒ์ ์๊ฐ์ ์ค์ผ ์ ์์ต๋๋ค.
์ฐธ๊ณ ๋งํฌ
- [geeksforgeeks] Difference between graph and tree
- https://gmlwjd9405.github.io/2018/08/12/data-structure-tree.html
๋ ์์๋ณด๊ธฐ
- ์ด์ง ํ(์ต๋ํ, ์ต์ํ)
- ๊ทธ๋ํ(Graph)