๊ทธ๋ํ์ ๋ถ๋ถ์งํฉ์ผ๋ก, ์ฌ์ดํด์ด ์๋ ํ๋์ ์ฐ๊ฒฐ ๊ทธ๋ํ๋ฅผ ๋ปํ๋ค.
์ฌ๊ธฐ์ ์ฌ์ดํด์ด ์๋ค๋ ๋ง์ ์ํํ์ง ์๋๋ค๋ ๋ป์ผ๋ก, ํธ๋ฆฌ๋ ์ต์์ ๋
ธ๋์ธ ๋ฃจํธ ๋
ธ๋์์ ์์ ๋
ธ๋๋ก ๋ป์ด๋๊ฐ๋ ๊ณ์ธต ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ด๋ฃจ๊ณ ์๋ค.
์ ์ฌ์ง์์ ์ผ์ชฝ์ ํธ๋ฆฌ, ์ค๋ฅธ์ชฝ์ ๊ทธ๋ํ๋ค. ๋์ ๋๋ ์ฐจ์ด์ ์
์ด ๋๊ฒ ๋ค. ๊ทธ ๋ฐ์๋ ์ฐจ์ด์ ์ ์ ๋ฆฌํด๋ณด์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
ํธ๋ฆฌ | ๊ทธ๋ํ | |
---|---|---|
๋ฐฉํฅ์ฑ | ๋ฐฉํฅ ๊ทธ๋ํ (์์์ ์๋๋ก) | ๋ฐฉํฅ ๊ทธ๋ํ, ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ๋ชจ๋ ์กด์ฌ |
์ฌ์ดํด | ์ฌ์ดํด์ด ๋ถ๊ฐ๋ฅํ ๋น์ํ ๊ทธ๋ํ | ์ฌ์ดํด์ด ์๋ ์ํ ๊ทธ๋ํ, ์ฌ์ดํด์ด ์๋ ๋น์ํ ๊ทธ๋ํ ๋ชจ๋ ์กด์ฌ |
๋ฃจํธ ๋ ธ๋ | ๋จ ํ๊ฐ์ ๋ฃจํธ ๋ ธ๋ ์กด์ฌ | ๋ฃจํธ ๋ ธ๋๋ผ๋ ๊ฐ๋ ์์ฒด๊ฐ ์์ |
๋ถ๋ชจ-์์ | ๋ชจ๋ ์์ ๋
ธ๋๋ ํ๋์ ๋ถ๋ชจ ๋
ธ๋๋ฅผ ๊ฐ์ง ๋ถ๋ชจ-์์ ๊ด๊ณ ์กด์ฌ | ๋ถ๋ชจ-์์์ด๋ผ๋ ๊ฐ๋ ์์ฒด๊ฐ ์์ |
๋ชจ๋ธ | ๊ณ์ธต ๋ชจ๋ธ | ๋คํธ์ํฌ ๋ชจ๋ธ |
๊ฐ์ ์ ์ | ๋
ธ๋ ๋น ์ฐ๊ฒฐ๋ ๊ฐ์ ์ ์๋ ๋ฌด์กฐ๊ฑด 1๊ฐ ์ด์ ๋ ธ๋๊ฐ N์ธ ํธ๋ฆฌ๋ ํญ์ (N-1)์ ๊ฐ์ ์ ๊ฐ์ง | 0๊ฐ ์ด์ (์์ด๋ ๋ฌด๋ฐฉ) ๊ทธ๋ํ์ ๋ฐ๋ผ ๊ฐ์ ์ ์๊ฐ ๋ค๋ฆ |
๋ฐฉํฅ์ฑ | ๋ฐฉํฅ ๊ทธ๋ํ (์์์ ์๋๋ก) | ๋ฐฉํฅ ๊ทธ๋ํ, ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ ๋ชจ๋ ์กด์ฌ |
ํธ๋ฆฌ๋ฅผ ๊ตฌํํ๊ธฐ ์ํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
public class TreeNode<T> {
public var value: T
public weak var parent: TreeNode?
public var children = [TreeNode<T>]()
public init(value: T) {
self.value = value
}
public func addChild(_ node: TreeNode<T>) { /
children.append(node)
node.parent = self
}
}
์ด์ง ํธ๋ฆฌ๋ ๊ฐ ๋ ธ๋์์ ์ต๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ง ์ง๋ ์ ์๋ ํธ๋ฆฌ๋ก, ์ต๋ ๋ผ๋ ๋จ์ด๊ฐ ์ค์ํ๋ค. ๊ผญ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง์ง ์์๋ ๋๋ค! ์ด์ง ํธ๋ฆฌ ์์์๋ ์ฌ๋ฌ ๊ฐ์ ํธ๋ฆฌ๊ฐ ๋๋๋๋ฐ, ์์ธํ ๊ฑด ๋ฐ์์ ์ดํด๋ณด๊ฒ ๋ค.
๊ฐ ๋ ธ๋๋ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ์๋์ง, ์์ ๋ ธ๋๋ฅผ 2๊ฐ ๊ฐ์ ธ์ผ ํ๋ค. ๋ง ๊ทธ๋๋ก ์ ๋ง ํ(full) ์ด์ง ํธ๋ฆฌ๋ค.
๋ง์ง๋ง ๋จ๊ณ๋ฅผ ์ ์ธํ ๋ชจ๋ ๋จ๊ณ์ ๋ ธ๋๊ฐ ์์ ํ ์ฑ์์ ธ ์๋ ์ํ์ ํธ๋ฆฌ๋ค. ๋ง์ง๋ง ๋จ๊ณ์ ๋ ธ๋๋ ์ข์ธก๋ถํฐ ์ฑ์์ ธ์ผ ํ๋ค๋ ์ ์ฝ๋ ์๋ค.
๋ชจ๋ ๋ด๋ถ ๋ ธ๋๋ 2๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค. ๋ํ ๋ชจ๋ ์(leaf) ๋ ธ๋๋ฅผ ๋์ผํ ๊น์ด๋ฅผ ๊ฐ์ ธ์ผ ํ๋ค.
๋
ธ๋๊ฐ ์ญ์ ๋๊ฑฐ๋ ์ฝ์
๋ ๊ฒฝ์ฐ ํธํฅ๋ ์ด์ง ํธ๋ฆฌ๊ฐ ๋๋ ๊ฒ์ ๋ง๊ธฐ ์ํด, ์ ๋
ธ๋๊น์ง์ ๊น์ด๋ฅผ ์๊ฒ ์ ์งํ๋๋ก ํ๋ ํธ๋ฆฌ๋ค.
ํธํฅ๋ ์ด์ง ํธ๋ฆฌ๊ฐ ๋์ง ์๋๋ก ํ๋ ์ด์ ๋ ์ด์ง ํ์ ํธ๋ฆฌ์ ๊ท์น ๋๋ฌธ์ด๋ค. ์ด์ง ํ์ ํธ๋ฆฌ์์๋ ๋ถ๋ชจ ๋
ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ์ ์๋ ๋
ธ๋๋ ๋ถ๋ชจ ๋
ธ๋๋ณด๋ค ์์์ผ ํ๊ณ , ์ค๋ฅธ์ชฝ์ ์๋ ๋
ธ๋๋ ๋ถ๋ชจ ๋
ธ๋๋ณด๋ค ์ปค์ผ ํ๋ค. ๊ทธ๋ฐ๋ฐ ํธ๋ฆฌ์ ๊น์ด๊ฐ ๊น์ด์ง๋ฉด ํ์ํด์ผ ํ๋ ํ์๊ฐ ๋์ด๋๊ณ , ์ด ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋ O(n)
์ด ๋๋ค.
์ด๋ฌํ ๊ฒฝ์ฐ๋ฅผ ํผํ๊ธฐ ์ํด ๋์ด๋ฅผ ์ต์๋ก ์ ์งํด์ผ ํ๊ณ , ์ต์๋ก ์ ์งํ๊ธฐ ์ํด ๊ท ํ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ด์ฉํ๋ค. ์ด ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋ O(logn)
์ด๋ค.
์ ์ฌ์ง์ 15๋ฅผ ์ฝ์ ํ์ ๋ ์ด๋ป๊ฒ ๊ท ํ ์ด์ง ํธ๋ฆฌ์์ ๊น์ด๋ฅผ ์๊ฒ ์ ์งํ๋์ง ๋ณด์ฌ์ฃผ๋ ์์๋ค.
์์์๋ ์ ๊น ์ค๋ช ํ๋๋ฐ, ์ด์ง ํ์ ํธ๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ๊ฐ์ง๊ณ ์๋ ํธ๋ฆฌ๋ค.
์ด์ง ํ์ ํธ๋ฆฌ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๊ฑฐ๋ ์ถ๊ฐํ๊ฑฐ๋ ์ญ์ ํ ๋, ํธ๋ฆฌ์ ๊น์ด(depth)๊ฐ ์ผ๋ง๋ ๋๋์ ๋ฐ๋ผ ์๊ฐ๋ณต์ก๋๋ O(n)
์์ O(logn)
์ ๊ฐ์ ๊ฐ์ง ์ ์๋ค. ์๊ฐ๋ณต์ก๋๋ ์์์ ์ค๋ช
ํ์ผ๋ ๋์ด๊ฐ๊ฒ ๋ค.
ํธ๋ฆฌ๋ ํฌ๊ฒ ์ธ ๊ฐ์ ์ํ ๋ฐฉ์์ ๊ฐ์ง ์ ์๋ค. ์ด๋ ์ํ ๋ฐฉ์์ด๋ ํน์ ํ ์์์ ๋ฐ๋ผ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ ๊ฒ์ผ๋ก, pre-order, post-order, in-order๊ฐ ์๋ค. ์ด๋ฆ์ด ์ ๋ ๊ฒ ๋ถ์ฌ์ง ์ด์ ๋ ๋ฃจํธ ๋ ธ๋๋ฅผ ์ด๋ค ์์๋ก ๋ฐฉ๋ฌธํ๋์ ๋ฐ๋ผ ๋ฐ๋๋ ๊ฒ ๊ฐ์๋ฐ, pre-order๋ ๋ฃจํธ ๋ ธ๋๋ฅผ ๋จผ์ , in-order๋ ๋ฃจํธ ๋ ธ๋๋ฅผ ์ค๊ฐ์, post-order๋ ๋ฃจํธ ๋ ธ๋๋ฅผ ์ ์ผ ๋ง์ง๋ง์ ๋ฐฉ๋ฌธํ๋ค. ์์ธํ ์ค๋ช ์ ๋ฐ์์!
Pre-order ๋ฐฉ์์ ๋ฃจํธ ๋ ธ๋ -> ์ผ์ชฝ ๋ ธ๋ -> ์ค๋ฅธ์ชฝ ๋ ธ๋ ์์๋ก ์๋ธํธ๋ฆฌ๋ฅผ ๋ฐฉ๋ฌธํ๋ค. ์ด ๋ ๋ฐฉ๋ฌธ์ ์ฌ๊ท์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋๋ฐ, ์ ์ฌ์ง์ ๋ณด๋ฉด ๋๋ต์ ์ผ๋ก ์ด๋ค ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ์ ์ ์๋ค.
์ฝ๋๋ก ๊ตฌํํ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ๋ค.
func PreOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
print(node.value)
BinaryTreeNode.PreOrder(node: node.leftChild)
BinaryTreeNode.PreOrder(node: node.rightChild)
}
์ฌ์ง์ ๋ณด๋ฉด ์๊ฒ ์ง๋ง ๋
ธ๋๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅ๋๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
In-order ๋ฐฉ์์ ์ผ์ชฝ ๋
ธ๋ -> ๋ฃจํธ ๋
ธ๋ -> ์ค๋ฅธ์ชฝ ๋
ธ๋ ์์๋ก ์๋ธํธ๋ฆฌ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํ๊ธฐ ๋๋ฌธ์, ๋
ธ๋์ ๊ฐ์ ์์ ๊ฐ๋ถํฐ ํฐ ๊ฐ๊น์ง ์ ๋ ฌ๋์ด ์ถ๋ ฅ๋๋ค.
์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
func InOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
BinaryTreeNode.InOrder(node: node.leftChild)
print(node.value)
BinaryTreeNode.InOrder(node: node.rightChild)
}
Post-order ๋ฐฉ์์ ์ผ์ชฝ ๋ ธ๋ -> ์ค๋ฅธ์ชฝ ๋ ธ๋ -> ๋ฃจํธ ๋ ธ๋ ์์๋ก ์๋ธํธ๋ฆฌ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋ค.
์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
func PostOrder(node: BinaryTreeNode?) {
guard let node = node else {
return
}
BinaryTreeNode.PostOrder(node: node.leftChild)
BinaryTreeNode.PostOrder(node: node.rightChild)
print(node.value)
}
Binary Trees (Part 4) - Discussing (in) Depth-First Traversals
[์๋ฃ๊ตฌ์กฐ] ํธ๋ฆฌ(Tree)๋
[swift] ํธ๋ฆฌ / ๊ทธ๋ํ
[Swift] ์คํฐ๋ 5์ฃผ์ฐจ - ํธ๋ฆฌ ๊ตฌ์กฐ ๊ธฐ๋ฐ์ ์๊ณ ๋ฆฌ์ฆ