1๏ธโฃ ์ด์ง ํธ๋ฆฌ(Binary Tree).
์ด์ง ํธ๋ฆฌ(Binary Tree) ๋ ๊ฐ ๋ ธ๋๊ฐ ์ต๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ ๊ตฌ์กฐ์ ๋๋ค.
์ด ๋ ์์ ๋ ธ๋๋ ์ผ๋ฐ์ ์ผ๋ก ์ผ์ชฝ ์์(Left Child) ๊ณผ ์ค๋ฅธ์ชฝ ์์(Right Child) ์ด๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค.
์ด์ง ํธ๋ฆฌ๋ ๋ค์ํ ์์ฉ ํ๋ก๊ทธ๋จ์์ ์ค์ํ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
1๏ธโฃ ์ด์ง ํธ๋ฆฌ์ ๊ตฌ์ฑ ์์.
- ๋ ธ๋(Node) : ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ธฐ๋ณธ ๋จ์์ ๋๋ค.
- ๋ฃจํธ(Root) : ํธ๋ฆฌ์ ์ต์์ ๋ ธ๋์ ๋๋ค.
- ์์(Child) : ํน์ ๋ ธ๋๋ก๋ถํฐ ์ฐ๊ฒฐ๋ ํ์ ๋ ธ๋์ ๋๋ค.
- ๋ถ๋ชจ(Parent) : ํน์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์์ ๋ ธ๋์ ๋๋ค.
- ์(Leaf) : ์์ ๋ ธ๋๊ฐ ์๋ ๋ ธ๋์ ๋๋ค.
- ์๋ธํธ๋ฆฌ(Subtree) : ํน์ ๋ ธ๋์ ๊ทธ ๋ ธ๋์ ๋ชจ๋ ์์ ๋ ธ๋๋ก ๊ตฌ์ฑ๋ ํธ๋ฆฌ์ ๋๋ค.
2๏ธโฃ ์ด์ง ํธ๋ฆฌ์ ์ข ๋ฅ.
-
ํฌํ ์ด์ง ํธ๋ฆฌ(Full Binary Tree) : ๋ชจ๋ ๋ ธ๋๊ฐ 0๊ฐ ๋๋ 2๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ ํธ๋ฆฌ์ ๋๋ค.
-
์์ ์ด์ง ํธ๋ฆฌ(Complete Binary Tree) : ๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ ๋ชจ๋ ๋ ๋ฒจ์ด ์์ ํ ์ฑ์์ ธ ์์ผ๋ฉฐ, ๋ง์ง๋ง ๋ ๋ฒจ์ ๋ ธ๋๋ ์ผ์ชฝ๋ถํฐ ์ฑ์์ ธ ์๋ ํธ๋ฆฌ์ ๋๋ค.
-
๋์ด ๊ท ํ ์ด์ง ํธ๋ฆฌ(Height-balanced binary Tree) : AVL ํธ๋ฆฌ์ ๊ฐ์ด ๊ฐ ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด ์ฐจ์ด๊ฐ 1 ์ดํ์ธ ํธ๋ฆฌ์ ๋๋ค.
-
์ด์ง ํ์ ํธ๋ฆฌ(Binary Search Tree, BST) : ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ชจ๋ ๋ ธ๋๊ฐ ๋ฃจํธ ๋ ธ๋๋ณด๋ค ์๊ณ , ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋ชจ๋ ๋ ธ๋๊ฐ ๋ฃจํธ ๋ ธ๋๋ณด๋ค ํฐ ํธ๋ฆฌ์ ๋๋ค.
3๏ธโฃ ์ด์ง ํธ๋ฆฌ์ ์ฃผ์ ์ฐ์ฐ ๋ฐ ์๊ฐ ๋ณต์ก๋.
-
์ฝ์
(Insertion) : ์๋ก์ด ๋
ธ๋๋ฅผ ํธ๋ฆฌ์ ์ถ๊ฐํฉ๋๋ค.
- ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋ : O(log n)(์ด์ง ํ์ ํธ๋ฆฌ์์)
- ์ต์ ์ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋ : O(n)(ํธํฅ๋ ํธ๋ฆฌ์์)
-
์ญ์ (Deletion) : ํธ๋ฆฌ์์ ํน์ ๋
ธ๋๋ฅผ ์ ๊ฑฐํฉ๋๋ค.
- ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋ : O(log n)(์ด์ง ํ์ ํธ๋ฆฌ์์)
- ์ต์ ์ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋: O(n)(ํธํฅ๋ ํธ๋ฆฌ์์)
-
ํ์(Search) : ํธ๋ฆฌ์์ ํน์ ๊ฐ์ ์ฐพ์ต๋๋ค.
- ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋: O(log n)(์ด์ง ํ์ ํธ๋ฆฌ์์)
- ์ต์ ์ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋ : O(n)(ํธํฅ๋ ํธ๋ฆฌ์์)
-
์ํ(Traversal) : ํธ๋ฆฌ์ ๋ชจ๋ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธํฉ๋๋ค. ์ํ ๋ฐฉ๋ฒ์๋ ์ ์(Preorder), ์ค์(Inorder), ํ์(Postorder) ์ํ๊ฐ ์์ต๋๋ค.
- ์๊ฐ ๋ณต์ก๋: O(n)(๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๊ธฐ ๋๋ฌธ์)
4๏ธโฃ ์ด์ง ํธ๋ฆฌ์ ์์
์ด์ง ํ์ ํธ๋ฆฌ(BST)์ ๊ตฌํ
// TreeNode
public class TreeNode {
int data;
TreeNode left;
TreeNode right;
public TreeNode(int data) {
this.data = data;
this.left = null;
this.right = null;
}
}
// BinarySearchTree
public class BinarySearchTree {
private TreeNode root;
public BinarySearchTree() {
this.root = null;
}
// ์ฝ์
์ฐ์ฐ
public void insert(int data) {
root = insertRec(root, data);
}
private TreeNode insertRec(TreeNode root, int data) {
if (root == null) {
root = new TreeNode(data);
return root;
}
if (data < root.data) {
root.left = insertRec(root.left, data);
} else if (data > root.data) {
root.right = insertRec(root.right, data);
}
return root;
}
// ํ์ ์ฐ์ฐ
public boolean search(int data) {
return searchRec(root, data);
}
private boolean searchRec(TreeNode root, int data) {
if (root == null) {
return false;
}
if (root.data == data) {
return true;
}
if (data < root.data) {
return searchRec(root.left, data);
} else {
return searchRec(root.right, data);
}
}
// ์ค์ ์ํ(Inorder Traversal)
public void inorder() {
inorderRec(root);
}
private void inorderRec(TreeNode root) {
if (root != null) {
inorderRec(root.left);
System.out.print(root.data + " ");
inorderRec(root.right);
}
}
}
// Main
public class Main {
public static void main(String[] args) {
BinarySearchTree bst = new BinarySearchTree();
bst.insert(50);
bst.insert(30);
bst.insert(20);
bst.insert(40);
bst.insert(70);
bst.insert(60);
bst.insert(80);
System.out.println("Inorder traversal of the BST:");
bst.inorder(); // ์ถ๋ ฅ: 20 30 40 50 60 70 80
System.out.println("\nSearch for 40: " + bst.search(40)); // ์ถ๋ ฅ: true
System.out.println("Search for 90: " + bst.search(90)); // ์ถ๋ ฅ: false
}
}