๐ Questions
- BST์ Binary Tree์ ๋ํด์ ์ค๋ช ํ์ธ์. (N์ฌ ์ ํ๋ฉด์ )
- Tree๊ฐ ๋ฌด์์ธ๊ฐ?
- ์ด์ง๊ฒ์ํธ๋ฆฌ์์ ๊ฒ์์๋๊ฐ ๊ฐ์ฅ ๋๋ฆฐ์ผ์ด์ค๋ ๋ฐ์ดํฐ๊ฐ ์ด๋ป๊ฒ ์ ์ฅ๋์ด ์๋ ๊ฒฝ์ฐ์ธ๊ฐ?
- ์ต์ ์คํจ๋ ํธ๋ฆฌ(Minimum Spanning Tree)์ ๋ํด์ ์ค๋ช ํด์ฃผ์ธ์.
- AVL ํธ๋ฆฌ๋?
Tree์ ๊ฐ๋
: ๋น์ ํ ๊ตฌ์กฐ๋ก, ์์๋ค ๊ฐ์ 1:n ๊ด๊ณ๋ฅผ ๊ฐ์ง๋ ์๋ฃ๊ตฌ์กฐ
๐ก ๋ฐ์ดํฐ๋ฅผ ์ด๋ป๊ฒ ์ฝ์
ํ๊ณ ์ญ์ ํ ๊ฒ์ธ์ง์ ๋ํด ๊ด์ฌ์ด ๋ง์๋ ์ ํ ์๋ฃ๊ตฌ์กฐ์ ๋นํด ๋น์ ํ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ์ ์ฝ์
/์ญ์ ๋ณด๋ค๋ โํํโ์ ํฌ์ปค์ค๊ฐ ๋ง์ถฐ์ ธ์๋ค.
ํธ๋ฆฌ๋ฅผ ์ด์ฉํด์ ๋ฌด์์ธ๊ฐ๋ฅผ ์ ์ฅํ๊ณ ๊บผ๋ด๊ธฐ ๋ณด๋ค ํธ๋ฆฌ๋ โ๋ฌด์์ธ๊ฐ๋ฅผ ํํํ๋ ๋๊ตฌโ๋ก ์์ฃผ ์ฌ์ฉ๋๊ธฐ ๋๋ฌธ์ด๋ค.
๋๋์ด ํ๋ฅผ ๋ง์ง๋ง์ผ๋ก ์ ํ(linear)์๋ฃ๊ตฌ์กฐ ๋ด์ฉ์ด ๋ง๋ฌด๋ฆฌ๋๊ณ ์ด์ ๋ถํฐ๋ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ์ ๋ํ ๋ด์ฉ์ด ์์๋๋ค. ๋น์ ํ ์๋ฃ๊ตฌ์กฐ์ ๋ํ์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ๋ก ํธ๋ฆฌ(Tree)์๋ฃ๊ตฌ์กฐ๋ค.
๊ฐ๊ณ๋๋ ์กฐ์ง๋ ๋ฑ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ก ๊ณ์ธตํ ๊ตฌ์กฐ๋ฅผ ํํํ๊ธฐ ์ด๋ ค์ธ ๋๊ฐ ์๋ค. ๊ณ์ธตํ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ ํํ๊ฐ ํธ๋ฆฌ์ด๋ค.
Tree ๊ตฌ์ฑ์์
Node
: ํธ๋ฆฌ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ธฐ๋ณธ ์์ (๋ฐ์ดํฐ์ ๋ค๋ฅธ ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๋ํ Branch ์ ๋ณด ํฌํจ)Root Node
: ํธ๋ฆฌ ๋งจ ์์ ์๋ ๋ ธ๋Parent Node
: ์ด๋ค ๋ ธ๋์ ๋ค์ ๋ ๋ฒจ์ ์ฐ๊ฒฐ๋ ๋ ธ๋ = ๋ถ๋ชจ๋ ธ๋Child Node
: ์ด๋ค ๋ ธ๋์ ์์ ๋ ๋ฒจ์ ์ฐ๊ฒฐ๋ ๋ ธ๋ = ์์๋ ธ๋Ancestor node
: ์ด๋ค ๋ ธ๋๋ณด๋ค ์(๋ฃจํธ์ชฝ)์ ์์นํ ๋ ธ๋(์ฐ๊ฒฐ๋ ์์ด์ผ ๋จ) ->ย10
,5
๋6
์ ์กฐ์๋ ธ๋ /15
๋6
์ ์กฐ์๋ ธ๋๊ฐ ์๋.descendant node
ย : ์กฐ์๋ ธ๋์ ์ญ ->ย H๋ F,G,I์ ํ์๋ ธ๋.Sibling (Brother Node)
: ๋์ผํ Parent Node๋ฅผ ๊ฐ์ง ๋ ธ๋. = ํ์ ๋ ธ๋Leaf Node (Terminal Node)
: Child Node๊ฐ ํ๋๋ ์๋ ๋ ธ๋. = ๋จ๋ง๋ ธ๋Level
: ์ต์์ ๋ ธ๋๋ฅผ Level 0์ผ๋ก ํ์์ ๋, ํ์ Branch๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๊น์ด๋ฅผ ๋ํ๋Depth
: ํธ๋ฆฌ์์ Node๊ฐ ๊ฐ์ง ์ ์๋ ์ต๋ LevelSub Tree
: ์ด๋ค ๋ ธ๋๋ฅผ ๋ฃจํธ๋ก ํ๊ณ ๊ทธ ์์์ผ๋ก ๊ตฌ์ฑ๋ ํธ๋ฆฌNull Tree
: ๋ ธ๋์ ๊ฐ์ง๊ฐ ์ ํ ์๋ ํธ๋ฆฌ, ๋ ํธ๋ฆฌ๋ผ๊ณ ๋ ํจ
Tree์ ํน์ง
- ๊ทธ๋ํ์ ํ ์ข ๋ฅ์ด๋ค. โ์ต์ ์ฐ๊ฒฐ ํธ๋ฆฌโ ๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค.
- ํธ๋ฆฌ๋ ๊ณ์ธต ๋ชจ๋ธ์ด๋ค.
- ํธ๋ฆฌ๋ DAG(Directed Acyclic Graphs, ๋ฐฉํฅ์ฑ์ด ์๋ ๋น์ํ ๊ทธ๋ํ)์ ํ ์ข ๋ฅ์ด๋ค.
- Loop๋ Circuit์ด ์๋ค. ๋น์ฐํ Self-loop๋ ์๋ค.
- ๋ ธ๋๊ฐ N๊ฐ์ธ ํธ๋ฆฌ๋ ํญ์ N-1๊ฐ์ ๊ฐ์ ์ ๊ฐ์ง๋ค.
- ๋ฃจํธ์์ ์ด๋ค ๋ ธ๋๋ก ๊ฐ๋ ๊ฒฝ๋ก๋ ์ ์ผํ๋ค.
- ํ ๊ฐ์ ๋ฃจํธ ๋ ธ๋๋ง์ด ์กด์ฌํ๋ฉฐ ๋ชจ๋ ์์ ๋ ธ๋๋ ํ ๊ฐ์ ๋ถ๋ชจ ๋ ธ๋๋ง์ ๊ฐ์ง๋ค.
- ์ํ๋ Pre-order, In-order ์๋๋ฉด Post-order๋ก ์ด๋ฃจ์ด์ง๋ค. ์ด 3๊ฐ์ง ๋ชจ๋ DFS/BFS์์ ์๋ค.
- ํธ๋ฆฌ์ ์ข
๋ฅ
- ์ด์งํธ๋ฆฌ
- ์ค๋ ๋ ์ด์ง ํธ๋ฆฌ
- ์ต์ ์ ์ฅ ํธ๋ฆฌ
- ์ด์งํ์ํธ๋ฆฌ
- ๊ท ํํธ๋ฆฌ (AVL Tree, Red Black Tree)
- ์ด์ง ํ
Binary Tree
: ํ๋ก๊ทธ๋๋ฐ์์ ๊ฐ์ฅ ๋ง์ด ์ฐ์ด๋ ํธ๋ฆฌ
- ์ด์ง ํธ๋ฆฌ๋ ๋ชจ๋ ๋ ธ๋๋ค์ด ๋ ๊ฐ์ ์๋ธ ํธ๋ฆฌ๋ฅผ ๊ฐ๋ ํน๋ณํ ํํ์ ํธ๋ฆฌ์ด๋ค.
- ๊ฐ ๋ ธ๋๊ฐ ์์ ๋ ธ๋๋ฅผ ์ต๋ ๋ ๊ฐ๊น์ง๋ง ๊ฐ์ง ์ ์๊ธฐ ๋๋ฌธ์ ๊ฐ ๋ ธ๋์ ์์ ๋ ธ๋๋ฅผ ์ผ์ชฝ ์์ ๋ ธ๋, ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ผ๊ณ ํ๋ค.
Binary Tree์ ํน์ง
- ๋ ๋ฒจ i ์์์ ๋ ธ๋์ ์ต๋ ๊ฐ์ : 2โฑ๊ฐ
-
๋์ด๊ฐ h์ธ ์ด์ง ํธ๋ฆฌ๊ฐ ๊ฐ์ง ์ ์๋ ๋ ธ๋์ ์ต์ ๊ฐ์ : (h+1)๊ฐ
์ต๋ ๊ฐ์ : **2^(h+1)-1**๊ฐ
Binary Tree์ ์ข ๋ฅ
์ด์งํธ๋ฆฌ๋ ์์๋ ธ๋๊ฐ ์ด๋ป๊ฒ ๊ตฌ์ฑ๋์ด ์๋์ ๋ฐ๋ผ ๋ค์๊ณผ ๊ฐ์ด 5๊ฐ์ง๋กย ๊ตฌ๋ถ๋๋ค.
โ Perfect Binary Tree (ํฌํ ์ด์ง ํธ๋ฆฌ)
-
๋ชจ๋ ๋ ๋ฒจ์ ๋ ธ๋๊ฐ ํฌํ ์ํ (left, right ์์๋ ธ๋๊ฐ ๋ชจ๋ ์กด์ฌ) ์ด์ง ํธ๋ฆฌ
-
๋์ด๊ฐ h์ผ ๋ ์ต๋์ ๋ ธ๋ ๊ฐ์์ธ 2^(h+1)-1๊ฐ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค.
-
๋ฃจํธ๋ฅผ 1๋ฒ์ผ๋ก ํ์ฌ 2^(h+1)-1๊น์ง ์ ํด์ง ์์น์ ๋ํ ๋ ธ๋ ๋ฒํธ๋ฅผ ๊ฐ์ง๋ค.
โ Complete Binary Tree (์์ ์ด์ง ํธ๋ฆฌ)
-
๋์ด๊ฐ h์ด๊ณ ๋ ธ๋ ์๊ฐ n๊ฐ์ผ ๋, ์ ์ด์ง ํธ๋ฆฌ์ ๋ ธ๋ ๋ฒํธ 1~n๋ฒ๊น์ง ๋น์๋ฆฌ๊ฐ ์๋ ์ด์ง ํธ๋ฆฌ
-
๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ ๋๋จธ์ง ๋ ธ๋๊ฐ ๊ฝ ์ฐจ ์์ด์ผ ํ๋ฉฐ(๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ๊ณ ํฌํ ์ด์ง ํธ๋ฆฌ์ด์ด์ผ ํ๋ฉฐ), ๋ง์ง๋ง ๋ ๋ฒจ์ ๋ ธ๋๋ ์ผ์ชฝ ๋ถํฐ ์ฐจ์์ด์ผ ํ๋ค.
โ Full Binary Tree (์ ์ด์ง ํธ๋ฆฌ) :
- ๋ชจ๋ ๋ ๋ฒจ์์ ๋ ธ๋๋ค์ด ๋ชจ๋ ์ฑ์์ ธ ์๋ ํธ๋ฆฌ
= Leaf Node๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋์ ์ฐจ์๊ฐ 2๊ฐ๋ก ์ด๋ฃจ์ด์ ธ ์์
- ํด๋น ์ฐจ์์ ๋ช ๊ฐ์ ๋ ธ๋๊ฐ ์กด์ฌํ๋์ง ๋ฐ๋ก ์ ์ ์์ผ๋ฏ๋ก ๋ ธ๋์ ๊ฐ์๋ฅผ ํ์ ํ ๋ ์ฉ์ดํจ
โ Skewed Binary Tree (ํธํฅ ์ด์ง ํธ๋ฆฌ)
-
๋์ด h์ ๋ํ ์ต์ ๊ฐ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ฉด์ ํ์ชฝ ๋ฐฉํฅ์ ์์ ๋ ธ๋๋ง์ ๊ฐ์ง ์ด์ง ํธ๋ฆฌ
-
์ผ์ชฝ ํธํฅ ์ด์ง ํธ๋ฆฌ, ์ค๋ฅธ์ชฝ ํธํฅ ์ด์ง ํธ๋ฆฌ๊ฐ ์์
-
ํธํฅ ์ด์ง ํธ๋ฆฌ๋ ๊ฒ์์ ์ฑ๋ฅ ์ด์๊ฐ ์์
โ ์ด๋ฐ ๋ฌธ์ ์ ์ ๊ทน๋ณตํ๊ธฐ์ํดย ย ๊ท ํํธ๋ฆฌ(AVLํธ๋ฆฌ,ย ๋ ๋-๋ธ๋ํธ๋ฆฌ) ๊ฐ์ ๋ณ์ข ์ด ์๊ฒจ๋ฌ๋ค.
โ Balanced Binary Tree (๊ท ํ ์ด์ง ํธ๋ฆฌ) :
-
ํธ๋ฆฌ์ย ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ผ์ด๋๋ ๊ฒฝ์ฐ์ ์๋์ผ๋ก ๊ทธ ๋์ด(๋ฃจํธ์์๋ถํฐ ๋ด๋ ค๊ฐ ์ ์๋ ์ต๋ ๋ ๋ฒจ)๋ฅผ ์๊ฒ ์ ์งํ๋ย ๋ ธ๋๊ธฐ๋ฐย ์ด์ง ํ์ ํธ๋ฆฌ
-
์ผ์ชฝ ๊ทธ๋ฆผ์ย ๊ท ํ์ด ๋ง์ง ์๋(unbalanced) ํธ๋ฆฌ
: ๋ฃจํธ โ ํน์ ๋ ธ๋ : ํ๊ท 3.27ํ์ ๋ ธ๋ ์ ๊ทผ
-
์ค๋ฅธ์ชฝ ๊ทธ๋ฆผ์ ๋์ผํ ์๋ฃ๋ฅผ ์ ์งํ๋ฉด์ย ํธ๋ฆฌ๋ฅผ ๋์ด ๊ท ํ์ ๋ง์ถ ํ์ ์ํ (๊ท ํ์ด์งํธ๋ฆฌ)
: ํ๊ท ์ด๋ ๋น์ฉ์ด 3.00 ๋ ธ๋ ์ ๊ทผ(node access)
-
AVLํธ๋ฆฌ, ๋ ๋-๋ธ๋ํธ๋ฆฌ๊ฐ ์๋ค.
Binary Tree์ ์ํ
์์ ํธ๋ฆฌ์ ๋ฌด์์ ํธ๋ฆฌ
ํธ๋ฆฌ๋ ํ์ ๋ ธ๋์ ์์ ๊ด๊ณ๊ฐ ์๋์ง์ ๋ฐ๋ผ 2์ข ๋ฅ๋ก ๋ถ๋ฅ๋๋ค. ํ์ ๋ ธ๋์ ์์ ๊ด๊ณ๊ฐ ์์ผ๋ฉด ์์ํธ๋ฆฌ, ๊ตฌ๋ณํ์ง ์์ผ๋ฉด ๋ฌด์์ ํธ๋ฆฌ๋ผ๊ณ ํ๋ค.
์์ ํธ๋ฆฌ์ ์ํ
-
๋๋น ์ฐ์ ๊ฒ์(BFS)
: ๋ฎ์ ๋ ๋ฒจ๋ถํฐ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฒ์ํ๊ณ , ํ ๋ ๋ฒจ์์ ๊ฒ์์ ๋ง์น๋ฉด ๋ค์ ๋ ๋ฒจ๋ก ๋ด๋ ค๊ฐ๋ ๋ฐฉ๋ฒ, ์ฆ ๋งจ ์์์๋ถํฐ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ, ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฒ์ํ๋๋ฒ
-
๊น์ด ์ฐ์ ๊ฒ์(DFS)
: ๋ฆฌํ์ ๋๋ฌํ ๋๊น์ง ์๋์ชฝ์ผ๋ก ๋ด๋ ค๊ฐ๋ฉด์ ๊ฒ์ํ๋ ๊ฒ์ ์ฐ์ ์ผ๋ก ํ๋ ๋ฐฉ๋ฒ, ๋ฆฌํ์ ๋๋ฌํด์ ๋ ์ด์ ๊ฒ์ํ ๊ณณ์ด ์์ผ๋ฉด ์ผ๋จ ๋ถ๋ชจ ๋ ธ๋๋ก ๋์๊ฐ๊ณ ๊ทธ ๋ค ๋ค์ ์์ ๋ ธ๋๋ก ๋ด๋ ค๊ฐ๋ค.
- ์ ์์ํ : ๋ ธ๋ ๋ฐฉ๋ฌธ -> ์ผ์ชฝ ์์ -> ์ค๋ฅธ์ชฝ ์์
- ์ค์์ํ : ์ผ์ชฝ ์์ -> ๋ ธ๋ ๋ฐฉ๋ฌธ -> ์ค๋ฅธ์ชฝ ์์
- ํ์์ํ : ์ผ์ชฝ ์์ -> ์ค๋ฅธ์ชฝ ์์ -> ๋ ธ๋ ๋ฐฉ๋ฌธ
Preorder Traversal (์ ์์ํ)
์ ์ ์ํ๋ VLR
์์๋ก ์ํํ๋ค.
V
ย : ํ์ฌ ๋ ธ๋๋ฅผ ์ถ๋ ฅํ๋คL
ย : ํ์ฌ ๋ ธ๋ ์ผ์ชฝ ์๋ธํธ๋ฆฌ๋ก ์ด๋ํ๋คR
ย : ํ์ฌ ๋ ธ๋ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ๋ก ์ด๋ํ๋ค
def preorderTraversal(self, node):
print(node, end='')
if not node.left == None : self.preorderTraversal(node.left)
if not node.right == None : self.preorderTraversal(node.right)
ํด๋น ๋ ธ๋๋ฅผ ์ถ๋ ฅํ๊ณ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๋ค. ์ผ์ชฝ ๋ ธ๋๊ฐ ์กด์ฌํ๋ฉด ๊ณ์ํด์ ์ผ์ชฝ์ผ๋ก ์ด๋ํ์ฌ ์ถ๋ ฅํ๊ณ ์ผ์ชฝ์ด ๋๋๋ ๋ ธ๋๋ถํฐ ์ค๋ฅธ์ชฝ ๋ ธ๋๋ฅผ ์ํํ๋ค.
Inorder Traversal (์ค์์ํ)
์ค์ ์ํ๋ย LVR
ย ์์๋ก ์ํํ๋ค. ์ผ์ชฝ ์ํ๊ฐ ์ฐ์ ์ด๊ณ ์ถ๋ ฅ์ด ์ค์์ ์์นํ๋ค.
def inorderTraversal(self, node):
if not node.left == None : self.inorderTraversal(node.left)
print(node, end='')
if not node.right == None : self.inorderTraversal(node.right)
Postorder Traversal (ํ์์ํ)
ํ์ ์ํ๋ย LRV
๋ก ์ํํ๋ค. ์ถ๋ ฅ์ด ๋ง์ง๋ง์ ์์นํ๋ค.
def postorderTraversal(self, node):
if not node.left == None : self.postorderTraversal(node.left)
if not node.right == None : self.postorderTraversal(node.right)
print(node, end='')
Binary Tree์ ํํ๋ฐฉ๋ฒ
- ๋ฐฐ์ด
-
1์ฐจ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ
- ์์ ์ด์งํธ๋ฆฌ์ ์์์ ๋์ผํ๊ฒ ์ธ๋ฑ์ฑํ๋ค.
- ํธ์์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ ์ฌ์ฉํ์ง ์๋๋ค.
-
์ด์ง ํธ๋ฆฌ์ ๊ฒฝ์ฐ, 2์ฐจ์ ๋ฐฐ์ด์ ์์ ๋ ธ๋๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ
-
๋ชจ๋ ํธ๋ฆฌ๊ฐ ๊ฐ๋ฅํ ๊ฒ ์๋.
์ด์ง ํธ๋ฆฌ๋ ๊ฐ ๋ ธ๋๊ฐ ์ต๋ ๋ ๊ฐ์ ์์์ ๊ฐ๋ ํธ๋ฆฌ์ด๊ธฐ ๋๋ฌธ์ 2์ฐจ์ ๋ฐฐ์ด๋ก ๊ฐ๋ฅํจ
-
A[i][0]์ ์ผ์ชฝ ์์, A[i][1]์ ์ค๋ฅธ์ชฝ ์์
-
-
์ฅ๋จ์
์ฅ์
: ๋ ธ๋์ ์์น๋ฅผ ์์ธ์ ์ํด ์ฝ๊ฒ ์ ๊ทผํ ์ ์๋ค.๋ฐฐ์ด์ ๊ธฐ๋ฐ์ผ๋ก ํ์ ๋ ์ฉ์ดํ ํธ๋ฆฌ ๊ด๋ จ ์ฐ์ฐ๋ ์กด์ฌํ๋ค.
๋จ์
: ํน์ ํธ๋ฆฌ์์ ๊ธฐ์ต ๊ณต๊ฐ ๋ญ๋น๊ฐ ์ฌํ ์ ์๋ค.
-
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ํํ
- ์ด์งํธ๋ฆฌ๋ฅผ ํ์ํ๋ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ
-
์ฐ๊ฒฐ๋ฆฌ์คํธ ๊ธฐ๋ฐ์์๋, ํธ๋ฆฌ์ ๊ตฌ์กฐ์ ๋ฆฌ์คํธ์ ์ฐ๊ฒฐ ๊ตฌ์กฐ๊ฐ ์ผ์น
โ ๊ตฌํ๊ณผ ๊ด๋ จ๋ ์ง๊ด์ ์ธ ์ดํด๊ฐ ๋ ์ข์ ํธ
- ์ผ์ชฝ ์์์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ํ๋, ์์ ํ๋, ์ค๋ฅธ์ชฝ ์์์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ํ๋๋ฅผ ํฌํจํ๋ ๋ ธ๋๋ก ํํํ๋ ๋ฐฉ๋ฒ
- ๋ชจ๋ ์ด์ง ํธ๋ฆฌ์ ๋ ธ๋๋ค์ ๋ฐ์ดํฐํ์ ์ด binaryTreeNode์ธ ์ค๋ธ์ ๋ก ํํ๋๋ค.
- ํ์ํ ๊ณต๊ฐ : n * sizeof(binaryTreeNode)
-
์ฅ๋จ์
์ฅ์
: ๊ธฐ์ต ์ฅ์๋ฅผ ์ ์ฝํ ์ ์๊ณ , ๋ ธ๋ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ฉ์ด๋จ์
: ์ด์ง ํธ๋ฆฌ๊ฐ ์๋ ์ผ๋ฐ ํธ๋ฆฌ์ ๊ฒฝ์ฐ ๊ฐ ๋ ธ๋์ ์ฐจ์๋งํผ ๊ฐ๋ณ์ ์ธ ํฌ์ธํฐ ํ๋๋ฅผ ๊ฐ์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์ ์ ๊ทผ์์ ์ด๋ ค์์ด ์์
Binary Tree Traversal
-
์ ์ ์ํ (preorder traversal)
DLR
์์๋ก, ํ์ฌ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ์ฌ ์ฒ๋ฆฌํ๋ ์์ D๋ฅผ ๊ฐ์ฅ ๋จผ์ ์ํ -
์ค์ ์ํ (inorder traversal)
LDR
์์๋ก, ํ์ฌ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ์ฌ ์ฒ๋ฆฌํ๋ ์์ D๋ฅผ ์์ L๊ณผ ์์ R์ ์ค๊ฐ์ ์ํ -
ํ์ ์ํ (postorder traversal)
LRD
์์๋ก, ํ์ฌ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ์ฌ ์ฒ๋ฆฌํ๋ ์์ D๋ฅผ ๊ฐ์ฅ ๋์ค์ ์ํ
Threaded Binary Trees
์ค๋ ๋ ์ด์ง ํธ๋ฆฌ
ํค๋ ๋
ธ๋๋ฅผ ์ ์ธํ ์ด์ง ์ค๋ ๋ ํธ๋ฆฌ
- n๊ฐ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๊ณ ์๋ ์ด์งํธ๋ฆฌ์๋ 2n๊ฐ์ ๋งํฌ๊ฐ ์กด์ฌ
- ์ด 2n๊ฐ์ ๋งํฌ ์ค n+1๊ฐ์ ๋งํฌ๊ฐ์
null
- Edge(๊ฐ์ ) ์๊ฐ n-1๊ฐ์ด๊ธฐ ๋๋ฌธ
- ๋ฃจํธ ๋ ธ๋ ์ ์ธ(- 1), ๋ชจ๋ ๋ ธ๋(n)๊ฐ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ํฅํ Edge๋ฅผ ๊ฐ์ง๊ณ ์์
- n + 1๊ฐ์ ํ ๋น ๊ณต๊ฐ์ด ์๊น๋ค๊ณ ์๊ฐํ ์ฌ๋๋ค์ด n + 1๊ฐ์ ๋งํฌ์ ๋ค๋ฅธ ์ ์ฉํ ์ ๋ณด๋ฅผ ์ง์ด ๋ฃ์๊ณ ์๊ฐ
-
Null ๋งํฌ๋ฅผ ๋ค๋ฅธ ๋ ธ๋์ ๋ํ ํฌ์ธํฐ๋ก ๋์ฒด โ ์ค๋ ๋(Threads)
โป ์ด์์ฒด์ , ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ด์ผ๊ธฐํ๋ ์ค๋ ๋์ ์์ ํ ๋ค๋ฅธ ๊ฒ
- ์ค๋ ๋๋ฅผ ํฌํจํ๊ณ ์๋ ํธ๋ฆฌ: ์ค๋ ๋ ์ด์ง ํธ๋ฆฌ
Threaded Binary Tree์ ํน์ง
- ํธ๋ฆฌ์ย ๋ ธ๋๋ ์์๋๋ก ์ฑ์์ง๋ค.
- ํธ๋ฆฌ์ ๋ค๋ฅธ ๋
ธ๋์ ๋ํ
thread
๋ผ๋ ํฌ์ธํฐ๋ก null ๋งํฌ๋ฅผ ๋ณ๊ฒฝํ๋ค - ์์ ๋
ธ๋์ ์ฐ๊ฒฐ๋์ง ์๋ ๋งํฌ๋
์ค์ ์ ํ์
(Inorder Predecessor) ๋๋์ค์ ํํ์
(Inoder Successor)์ ์ฐ๊ฒฐ๋๋ค. -
์ค์ ์ ํ์
๋๋์ค์ ํํ์
๊ฐ ์๋ ๋ ธ๋์ ๋งํฌ๋ย ๊ฐ์์ ๋ ธ๋head
๋ฅผ ๊ฐ๋ฆฌํจ๋ค. -
์ฅ์ : ํธ๋ฆฌ ์ ์ฒด์ ๋ชจ๋ ๋งํฌ๋ฅผย ํ์ฉํ๋ค.
์ค์ ์ํ์ ํธ์์ฑ์ด ์ฆ๋๋๋ค**.**
Thread์ ์ด์ฉ
-
ptr
->leftChild
=null
์ธ ๊ฒฝ์ฐ,ptr
โleft_child
๋ฅผ ptr์์ค์ ์ ํ์
๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝ์ค์ ์ ํ์
(Inorder Predecessor): ํด๋น ๋ ธ๋ ๋ฐ๋ก ์์ ๋์จ ๋ ธ๋
-
ptr
-> rightChild = null์ธ ๊ฒฝ์ฐ,ptr
โright_child
๋ฅผ ptr์์ค์ ํ์์
๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝ์ค์ ํ์์
(Inorder Successor): ํด๋น ๋ ธ๋ ๋ฐ๋ก ๋ค์ ๋์ค๋ ๋ ธ๋
head ๋ ธ๋์ ํน์ง
- head ๋ ธ๋์ ์ผ์ชฝ ๋งํฌ๋ root ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํจ๋ค. (root ๋ ธ๋๋ ์ด์ง ํธ๋ฆฌ์ ์ฒซ๋ฒ์งธ ๋ ธ๋์ ๋๋ค.
- head ๋ ธ๋์ ์ค๋ฅธ์ชฝ ๋งํฌ๋ head, ์ฆ, ์๊ธฐ ์์ ์ ๊ฐ๋ฆฌํจ๋ค.
- head ๋ ธ๋์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ ์๋ค.
- head๋ฅผ ์ ์ธํ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ค์ ์ํ ํ ๋ ์ฒซ๋ฒ์จฐ ๋ ธ๋์ ์ผ์ชฝ ๋งํฌ์ ๋ง์ง๋ง ๋ ธ๋์ ์ค๋ฅธ์ชฝ ๋งํฌ๋ head๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
An Empty Threaded Binary Tree
Threaded Binary Tree์ ์ค์ ์ํ
- ์ค๋ ๋๋ฅผ ์ถ๊ฐํด์ ์ป๋ ์ด๋: ์ค์ ์ํ๋ฅผ ์์ฃผ ์ฝ๊ฒ ์ํ ๊ฐ๋ฅ
Step 1. ์ค์ ํ์์ ์ฐพ๊ธฐ
- ptr์ด ํ์ฌ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํจ๋ค๊ณ ๊ฐ์
-
If
ptr
โright_thread
==TRUE
โ ์ค์ ์ํ์์
ptr ๋ค์ ๋ ธ๋
=ptr
โright_child
-
Otherwise
โ
ptr
์right_child
๋ก ๊ฐ ๋ค์,left_child
๋ฅผ ๋ฐ๋ผ ๊ณ์ ๋ด๋ ค๊ฐ๋ค.โ ์ธ์ ๊น์ง?
left_thread
==TRUE
์ธ ๋ ธ๋๋ฅผ ๋ง๋ ๋ ๊น์ง
Step 2. ์ค์ ํ์์ ๋ฐ๊ฒฌ ์๊ณ ๋ฆฌ์ฆ : insucc
struct thread_tree *insucc(struct thread_tree *ptr)
{ // ์ค๋ ๋ ์ด์ง ํธ๋ฆฌ์์ ptr์ด ๊ฐ๋ฆฌํค๋ ๋
ธ๋์ inorder successor return
struct thread_tree *temp = ptr->right_child;
if (!ptr->right_thread) // right_child๊ฐ ์์ ๋
ธ๋์ด๋ฉด
while (!temp->left_thread) // ์ผ์ชฝ ๋๊น์ง ๊ฐ์
temp = temp->left_child;
return temp;
}
Step 3. ์ค์ ์ํ ์๊ณ ๋ฆฌ์ฆ : tinorder
void tinorder(struct thread_tree *tree)
{ // ์ค๋ ๋ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ค์ ์ํ. ํค๋ ๋
ธ๋๋ถํฐ ์์
struct thread_tree *temp = tree;
for ( ; ; )
{
temp = insucc(temp);
if (temp == tree) // ํด๋น ๋
ธ๋์ ์ค์ ํ์์๊ฐ ํค๋ ๋
ธ๋๋ฉด(๋ค ๋์์ผ๋ฉด)
break;
printf("%3c", temp->data);
}
}
-
์ํ ์๊ณ ๋ฆฌ์ฆ ์ฌ์ฉํ์ง ์๊ณ ์ค์ ์ํ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๊ฐ๋ฅ
โ ๋์ฑ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ
-
์ํ ์๊ณ ๋ฆฌ์ฆ ์ด์ฉ์ overhead๊ฐ ์ปค์ง
Threaded Binary Tree์์ Node ์ถ๊ฐํ๊ธฐ
์๋ก์ด ๋ ธ๋๋ฅผ parent ๋ ธ๋์ right child ๋ก ์ถ๊ฐํ๋ค๊ณ ๊ฐ์ ํด๋ณด์.
- Case 1 : parent โ right_thread ๊ฐ์ด true์ผ ๊ฒฝ์ฐ
- Case 2 : parent โ right_thread ๊ฐ์ด false์ผ ๊ฒฝ์ฐ
Case 1 : parent
โright_thread
== TRUE
- 3๊ฐ์ง ํฌ์ธํฐ ๋ณ๊ฒฝ์ด ํ์
- B์์ D๋ก ์ฐ๊ฒฐ๋๋ ๋งํฌ
- ์๋ก ์ถ๊ฐ๋ ๋ ธ๋ D์ left, right child
Case 2 : parent
โright_thread
== FALSE
-
์ด๋ฏธ ๊ธฐ์กด ๋ ธ๋๊ฐ ์ค๋ฅธ์ชฝ ์์์ผ๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ฒฝ์ฐ
โ ๊ธฐ์กด ๋ ธ๋์ ์ค์ ํ์์์ ์ค์ ์ ํ์๊น์ง ๋ฐ๊ฟ์ผ (์ด 4๊ฐ์ง ํฌ์ธํฐ)
์ค๋ฅธ์ชฝ์ ์ถ๊ฐํ๋ ์๊ณ ๋ฆฌ์ฆ
void insert_right(struct thread_tree *parent, struct thread_tree *child)
{ // ์ค๋ ๋ ์ด์ง ํธ๋ฆฌ์์ parent ์ค๋ฅธ์ชฝ์ child ์ถ๊ฐ
struct thread_tree *temp;
child->right_child = parent->right_child; // child์
child->right_thread = parent->right_thread; // ์ ๋ณด๋ถํฐ
child->left_child = parent; // ๋ณ๊ฒฝ
child->left_thread = TRUE; // ํ์
parent->right_child = child;
parent->right_thread = FALSE; // child๊ฐ ์กด์ฌํ๋ฏ๋ก thread๋ false
if (!child->right_thread)
{
temp = insucc(child); // parent์ ์๋ successor๋ฅผ ์ฐพ์์
temp->left_child = child; // ์๋ก์ด predecessor๋ก ๋ณ๊ฒฝ
}
}
- ์ฐธ๊ณ ์๋ฃ
- ์ค์ฑ์ฐ์ ์ดํ ์๋ฃ๊ตฌ์กฐ
- SW Expert Academy
- https://www.fun-coding.org/Chapter10-tree.html
- https://blex.me/@baealex/ํ์ด์ฌ์ผ๋ก-๊ตฌํํ-์๋ฃ๊ตฌ์กฐ-ํธ๋ฆฌ
- https://jackpot53.tistory.com/7
- https://smujihoon.tistory.com/153
- https://blog.naver.com/PostView.naver?blogId=boldfaced7&logNo=222261232275&parentCategoryNo=&categoryNo=28&viewDate=&isShowPopularPosts=true&from=search
- https://lsoovmee-rhino.tistory.com/47
- https://blog.naver.com/PostView.naver?blogId=boldfaced7&logNo=222261232275&parentCategoryNo=&categoryNo=28&viewDate=&isShowPopularPosts=true&from=search