Home > Algorithm > 2024 > πŸ“¦[DS,Algorithm] 이진 트리(Binary Tree)

πŸ“¦[DS,Algorithm] 이진 트리(Binary Tree)
DataStructure Algorithm

1️⃣ 이진 트리(Binary Tree).

이진 트리(Binary Tree) λŠ” 각 λ…Έλ“œκ°€ μ΅œλŒ€ 두 개의 μžμ‹ λ…Έλ“œλ₯Ό κ°€μ§ˆ 수 μžˆλŠ” 트리 κ΅¬μ‘°μž…λ‹ˆλ‹€.

이 두 μžμ‹ λ…Έλ“œλŠ” 일반적으둜 μ™Όμͺ½ μžμ‹(Left Child) κ³Ό 였λ₯Έμͺ½ μžμ‹(Right Child) 이라고 λΆˆλ¦½λ‹ˆλ‹€.

이진 νŠΈλ¦¬λŠ” λ‹€μ–‘ν•œ μ‘μš© ν”„λ‘œκ·Έλž¨μ—μ„œ μ€‘μš”ν•œ μžλ£Œκ΅¬μ‘°μž…λ‹ˆλ‹€.

1️⃣ 이진 트리의 ꡬ성 μš”μ†Œ.

  • λ…Έλ“œ(Node) : 데이터λ₯Ό μ €μž₯ν•˜λŠ” κΈ°λ³Έ λ‹¨μœ„μž…λ‹ˆλ‹€.
  • 루트(Root) : 트리의 μ΅œμƒμœ„ λ…Έλ“œμž…λ‹ˆλ‹€.
  • μžμ‹(Child) : νŠΉμ • λ…Έλ“œλ‘œλΆ€ν„° μ—°κ²°λœ ν•˜μœ„ λ…Έλ“œμž…λ‹ˆλ‹€.
  • λΆ€λͺ¨(Parent) : νŠΉμ • λ…Έλ“œλ₯Ό κ°€λ¦¬ν‚€λŠ” μƒμœ„ λ…Έλ“œμž…λ‹ˆλ‹€.
  • 잎(Leaf) : μžμ‹ λ…Έλ“œκ°€ μ—†λŠ” λ…Έλ“œμž…λ‹ˆλ‹€.
  • μ„œλΈŒνŠΈλ¦¬(Subtree) : νŠΉμ • λ…Έλ“œμ™€ κ·Έ λ…Έλ“œμ˜ λͺ¨λ“  μžμ‹ λ…Έλ“œλ‘œ κ΅¬μ„±λœ νŠΈλ¦¬μž…λ‹ˆλ‹€.

2️⃣ 이진 트리의 μ’…λ₯˜.

  1. 포화 이진 트리(Full Binary Tree) : λͺ¨λ“  λ…Έλ“œκ°€ 0개 λ˜λŠ” 2개의 μžμ‹ λ…Έλ“œλ₯Ό κ°€μ§€λŠ” νŠΈλ¦¬μž…λ‹ˆλ‹€.

  2. μ™„μ „ 이진 트리(Complete Binary Tree) : λ§ˆμ§€λ§‰ λ ˆλ²¨μ„ μ œμ™Έν•œ λͺ¨λ“  레벨이 μ™„μ „νžˆ μ±„μ›Œμ Έ 있으며, λ§ˆμ§€λ§‰ 레벨의 λ…Έλ“œλŠ” μ™Όμͺ½λΆ€ν„° μ±„μ›Œμ Έ μžˆλŠ” νŠΈλ¦¬μž…λ‹ˆλ‹€.

  3. 높이 κ· ν˜• 이진 트리(Height-balanced binary Tree) : AVL νŠΈλ¦¬μ™€ 같이 각 λ…Έλ“œμ˜ μ™Όμͺ½ μ„œλΈŒνŠΈλ¦¬μ™€ 였λ₯Έμͺ½ μ„œλΈŒνŠΈλ¦¬μ˜ 높이 차이가 1 μ΄ν•˜μΈ νŠΈλ¦¬μž…λ‹ˆλ‹€.

  4. 이진 탐색 트리(Binary Search Tree, BST) : μ™Όμͺ½ μ„œλΈŒνŠΈλ¦¬μ˜ λͺ¨λ“  λ…Έλ“œκ°€ 루트 λ…Έλ“œλ³΄λ‹€ μž‘κ³ , 였λ₯Έμͺ½ μ„œλΈŒ 트리의 λͺ¨λ“  λ…Έλ“œκ°€ 루트 λ…Έλ“œλ³΄λ‹€ 큰 νŠΈλ¦¬μž…λ‹ˆλ‹€.

3️⃣ 이진 트리의 μ£Όμš” μ—°μ‚° 및 μ‹œκ°„ λ³΅μž‘λ„.

  1. μ‚½μž…(Insertion) : μƒˆλ‘œμš΄ λ…Έλ“œλ₯Ό νŠΈλ¦¬μ— μΆ”κ°€ν•©λ‹ˆλ‹€.
    • 일반적인 경우 μ‹œκ°„ λ³΅μž‘λ„ : O(log n)(이진 탐색 νŠΈλ¦¬μ—μ„œ)
    • μ΅œμ•…μ˜ 경우 μ‹œκ°„ λ³΅μž‘λ„ : O(n)(편ν–₯된 νŠΈλ¦¬μ—μ„œ)
  2. μ‚­μ œ(Deletion) : νŠΈλ¦¬μ—μ„œ νŠΉμ • λ…Έλ“œλ₯Ό μ œκ±°ν•©λ‹ˆλ‹€.
    • 일반적인 경우 μ‹œκ°„ λ³΅μž‘λ„ : O(log n)(이진 탐색 νŠΈλ¦¬μ—μ„œ)
    • μ΅œμ•…μ˜ 경우 μ‹œκ°„ λ³΅μž‘λ„: O(n)(편ν–₯된 νŠΈλ¦¬μ—μ„œ)
  3. 탐색(Search) : νŠΈλ¦¬μ—μ„œ νŠΉμ • 값을 μ°ΎμŠ΅λ‹ˆλ‹€.
    • 일반적인 경우 μ‹œκ°„ λ³΅μž‘λ„: O(log n)(이진 탐색 νŠΈλ¦¬μ—μ„œ)
    • μ΅œμ•…μ˜ 경우 μ‹œκ°„ λ³΅μž‘λ„ : O(n)(편ν–₯된 νŠΈλ¦¬μ—μ„œ)
  4. 순회(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
  }
}