Tree๋ ๋ฐ์ดํฐ๋ฅผ ๊ฑฐ๊พธ๋ก๋ ๋๋ฌด ํํ๋ก ์ ์ฅํ๋ ์๋ฃ ๊ตฌ์กฐ๋ค. ์ฌ๋ฌ ์ ํ์ด ์์ง๋ง ๊ทธ ์ค ๊ฐ์ฅ ๊ธฐ๋ณธ์ binary tree(์ด์ง ํธ๋ฆฌ) ์๋ฃ๊ตฌ์กฐ๋ค. ์ด์ง ํธ๋ฆฌ๋ ๋๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ํธ๋ฆฌ ํํ!
Tree ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ์ ์ ์ฅ์ ์๋ฏธ ๋ณด๋ค๋ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๋ ํจ๊ณผ์ ์ผ๋ก ํ์ ํ๊ธฐ ์ํด์
์ฌ์ฉ๋๋ค. ์ผ๋ฐ list๋ ๊ฒ์์ด O(N)์ธ๋ฐ์ ๋นํด ์ด์ง ํธ๋ฆฌ๋ O(log N) ์ด๋ฏ๋ก ๋ฆฌ์คํธ ๋ณด๋ค ๊ฒ์์ด ํจ์ฌ ํจ์จ ์ ์ด๋ค.
ํธ๋ฆฌ์ ์์ฑ ์ค ๊ฐ์ฅ ์ค์ํ ๊ฒ์ด '๋ฃจํธ ๋ ธ๋๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋๋ ๋จ ํ๋์ ๋ถ๋ชจ๋ ธ๋๋ง์ ๊ฐ์ง๋ค'๋ ๊ฒ์ด๋ค. ๊ธฐ๋ณธ ๊ฐ๋ ์ ๋ ธ๋์ ๋ฃจํธ ๋ ธ๋์ด๊ณ , ๋๋จธ์ง ๊ฐ๋ ์ ๋ํด์๋ ์ ๋ฆฌ๊ฐ ํ์ํ๋ค.
ํธ๋ฆฌ์ ์ํ๋ ํธ๋ฆฌ์ ๊ฐ ๋ ธ๋๋ฅผ ์ฒด๊ณ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ๋ฐฉ๋ฌธํ๋ ๊ณผ์ ์ ๋งํ๋ค. ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ ์์์ ๋ฐ๋ผ ์ ์์ํ, ์ค์ ์ํ, ํ์์ํ ์ธ๊ฐ์ง๋ก ๋๋๋ค. ์ด๋ฏธ์ง ๋ฐ ๋ด์ฉ์ ์ํคํผ๋์!
์์
์ ์ ์ํ: F, B, A, D, C, E, G, I, H (root, left, right)
์ค์ ์ํ: A, B, C, D, E, F, G, H, I (left, root, right)
ํ์ ์ํ: A, C, E, D, B, H, I, G, F (left, right, root)
๋ ๋ฒจ ์์ ์ํ: F, B, G, A, D, I, C, E, H
skewed binary tree. ํธํฅ์ด์ง ํธ๋ฆฌ๋ ํ๋์ ์ฐจ์๋ก๋ง ์ด๋ค์ ธ ์๋ ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ์ด๋ฐ ๊ตฌ์กฐ๋ ๋ฐฐ์ด๊ณผ ๊ฐ์ ์ ํ ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ Leaf Node (๊ฐ์ฅ ๋ ๋ ธ๋)ํ์์ ๊ฒฐ๊ตญ ๋ชจ๋ ์ฝ์ด ๋ค์ฌ์ผ ํ๋ค๋ ๋จ์ ์ด ์์ด์ ํจ์จ์ด ๋จ์ด์ง๋ค๊ณ ๋งํ๋ค. ์ด๊ฐ์ ์ ์ ๋ณด์ํ๊ธฐ ์ํด '๋์ด ๊ท ํ ํธ๋ฆฌ'๋ผ๋ ๊ฒ์ด ์๋ค.
full binary tree. ํฌํ์ด์ง ํธ๋ฆฌ๋ Leaf Node๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋์ ์ฐจ์๊ฐ ๋๊ฐ๋ก ์ด๋ค์ง ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ์ด ๊ฒฝ์ฐ์๋ ํด๋น ์ฐจ์์ ๋ช๊ฐ์ ๋ ธ๋๊ฐ ์กด์ฌํ๋์ง ๋ฐ๋ก ์์ ์์ด ๊ฐ์ ํ์ ์ด ์ฉ์ดํ๋ค๋ ์ฅ์ ์ด ์๋ค.
complete binary tree. ํฌํ ์ด์งํธ๋ฆฌ์ ๊ฐ์ ๊ฐ๋ ์ผ๋ก ์์ฑํ์ง๋ง ๋ชจ๋ ๋ ธ๋๊ฐ ์ผ์ชฝ๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ์์ฑ๋๋ ์ด์ง ํธ๋ฆฌ๋ฅผ ๋งํ๋ค.
binary search tree. ์ด์ง ํ์ ํธ๋ฆฌ์์๋ ํญ์ ๋ถ๋ชจ ๋
ธ๋๊ฐ ์ผ์ชฝ ์์๋ณด๋ค๋ ํฌ๊ณ , ์ค๋ฅธ์ชฝ ์์๋ณด๋ค๋ ์๋ค.
์ด๋ฌํ ํน์ฑ ๋๋ถ์ ์ด์งํ์ํธ๋ฆฌ์์๋ ํ๋ฒ ํ์ธํ ๋ ใ
๋ง๋ค ๋ณด์์ผ ํ๋ ์์์ ๊ฐ์๊ฐ ์ ๋ฐ์ฉ ์ค์ด๋ ๋ค๋ ์ ์์ '์์ ์ด์ง ํธ๋ฆฌ'์ธ ๊ฒฝ์ฐ ํ์์๊ฐ์ O(logN)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค.
์ด์ง ํ์ ํธ๋ฆฌ์์ ํ์(traverse)์ ํ ๋๋ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์์ ๊ฒฝ์ฐ ์ผ์ชฝ ์์์ผ๋ก, ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ํด ๊ฒฝ์ฐ ์ค๋ฅธ์ชฝ ์์์ผ๋ก ์ด์ด ๋๊ฐ๋ฉด์ ๋ฐฉ๋ฌธ ํ๋ค. ์ด์ง ํ์ํธ๋ฆฌ๋ ์ด์ง ํ์์ด ํญ์ ๋์ํ๋๋ก ๊ตฌํํ์ฌ ํ์ ์๋๋ฅผ ๊ทน๋ํ์ํจ ์๋ฃ๊ตฌ์กฐ๋ค.
class Node:
def __init__(self, data):
self.left = None
self.right = None
self.data = data
def insert(self, data):
if self.data:
if data < self.data:
if self.left is None:
self.left = Node(data)
else:
self.left.insert(data)
elif data > self.data:
if self.right is None:
self.right = Node(data)
else:
self.right.insert(data)
else:
self.data = data
def findval(self, lkpval):
if lkpval < self.data:
if self.left is None:
return str(lkpval)+" Not Found"
return self.left.findval(lkpval)
elif lkpval > self.data:
if self.right is None:
return str(lkpval)+" Not Found"
return self.right.findval(lkpval)
else:
print(str(self.data) + ' is found')
def PrintTree(self):
if self.left:
self.left.PrintTree()
print(self.data)
if self.right:
self.right.PrintTree()
root = Node(12)
root.insert(6)
root.insert(14)
root.insert(3)
print(root.findval(7))
print(root.findval(14))