๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐ŸŽ iOS/Swift

[Swift] ์Šคํ„ฐ๋”” 5์ฃผ์ฐจ - ํŠธ๋ฆฌ ๊ตฌ์กฐ ๊ธฐ๋ฐ˜์˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜

by Danna 2021. 7. 26.
728x90
728x90

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)์˜ ์ง‘ํ•ฉ์œผ๋กœ ์ด๋ฃจ์–ด์ง„ ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ์ž…๋‹ˆ๋‹ค.

 

ํŠธ๋ฆฌ๋Š” ๊ทธ๋ž˜ํ”„์˜ ํ•œ ์ข…๋ฅ˜๋กœ, ์‚ฌ์ดํด์ด ์—†๋Š” ํ•˜๋‚˜์˜ ์—ฐ๊ฒฐ ๊ทธ๋ž˜ํ”„์ž…๋‹ˆ๋‹ค.

์‚ฌ์ดํด์ด ์—†๋‹ค๋Š” ๊ฒƒ์€ ๊ฐ™์€ ๋…ธ๋“œ๋ฅผ ์ˆœํ™˜ํ•˜์ง€ ์•Š๋Š”๋‹ค๋Š” ๋œป์ž…๋‹ˆ๋‹ค. ๋‘ ๋…ธ๋“œ ์‚ฌ์ด์— ๊ฒฝ๋กœ๊ฐ€ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค.

 

Tree vs Graph

 

โœ”๏ธŽ ์ด์ง„ ํŠธ๋ฆฌ(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 ํŠธ๋ฆฌ, ๋ ˆ๋“œ-๋ธ”๋ž™ํŠธ๋ฆฌ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

 

ํŽธํ–ฅ๋œ ์ด์ง„ ํŠธ๋ฆฌ vs ๊ท ํ˜• ์ด์ง„ ํŠธ๋ฆฌ

 

 

โœ”๏ธŽ ์ด์ง„ ํƒ์ƒ‰ ํŠธ๋ฆฌ(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)์˜ ํŠน์ˆ˜ํ•œ ํ˜•ํƒœ๋กœ ์ตœ๊ทผ์— ์ ‘๊ทผํ•œ ๋…ธ๋“œ๊ฐ€ ํŠธ๋ฆฌ์˜ ์ƒ์œ„๋กœ ์ด๋™ํ•˜๋Š” ํŠธ๋ฆฌ์ž…๋‹ˆ๋‹ค. ๋…ธ๋“œ์— ๋Œ€ํ•œ ์ ‘๊ทผ์ด ๋งค์šฐ ๋นˆ๋ฒˆํ•œ ์ƒํƒœ์—์„œ ์ตœ๊ทผ ๋ฐฉ๋ฌธํ•œ ๋…ธ๋“œ๋ฅผ ๊ณจ๋ผ๋‚ผ ์ˆ˜ ์žˆ์–ด, ๋…ธ๋“œ ๊ฒ€์ƒ‰ ์‹œ๊ฐ„์„ ์ค„์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


์ฐธ๊ณ ๋งํฌ

 

๋” ์•Œ์•„๋ณด๊ธฐ

  • ์ด์ง„ ํž™(์ตœ๋Œ€ํž™, ์ตœ์†Œํž™)
  • ๊ทธ๋ž˜ํ”„(Graph)
728x90
728x90