기수 정렬 오류 수정 및 보간 탐색 구현, 이진 탐색 트리 구현

yoonexample/src/main/java/search/InterpolSearch.java

@@ -0,0 +1,45 @@
+package search;
+
+public class InterpolSearch {
+
+  public static void main(String[] args) {
+    int[] arr = {1, 3, 5, 7, 9};
+
+    int idx = iSearch(arr, 7);
+    printSearchInfo(idx);
+
+    idx = iSearch(arr, 4);
+    printSearchInfo(idx);
+
+    idx = iSearch(arr, 2);
+    printSearchInfo(idx);
+  }
+
+  public static int iSearch(int[] arr, int target) {
+    int first = 0; // 탐색 대상의 시작 인덱스 값
+    int last = arr.length - 1; // 탐색 대상의 마지막 인덱스 값
+    int mid;
+
+    while (!(arr[first] > target || arr[last] < target)) {
+      mid = (int) ((double) (target - arr[first]) / (arr[last] - arr[first]) * (last - first))
+          + first;
+
+      if (arr[mid] == target) {
+        return mid;
+      } else if (target < arr[mid]) { // 탐색 대상이 아니라면 반으로 줄입니다.
+        last = mid - 1; // 왜 mid에서 1을 뺄까요?
+      } else {
+        first = mid + 1; // 왜 mid에서 1을 더할까요?
+      }
+    }
+    return -1;
+  }
+
+  public static void printSearchInfo(int idx) {
+    String info = "탐색 실패";
+    if (idx != -1) {
+      info = "타겟 저장 인덱스: " + idx;
+    }
+    System.out.println(info);
+  }
+}

yoonexample/src/main/java/search/binarysearchtree/BinarySearchTreeNode.java

@@ -0,0 +1,27 @@
+package search.binarysearchtree;
+
+import tree.binarytree.BinaryTreeNode;
+
+/**
+ * 이진 탐색 트리 자료구조의 ADT, 인터페이스이자 Node의 인터페이스
+ *
+ * @param <E> 데이터의 파라미터 타입
+ * @author dion
+ */
+public interface BinarySearchTreeNode<E> {
+
+  /**
+   * 해당 데이터를 가지고 있는 노드를 찾습니다.
+   *
+   * @param target 찾으려고 하는 데이터
+   * @return 해당 데이터를 가지고 있는 노드
+   */
+  BinaryTreeNode<E> search(E target);
+
+  /**
+   * 해당 데이터를 BST에 추가합니다.
+   *
+   * @param data BST에 저장할 데이터
+   */
+  void insert(E data);
+}

yoonexample/src/main/java/search/binarysearchtree/LinkedBinarySearchTreeNode.java

@@ -0,0 +1,65 @@
+package search.binarysearchtree;
+
+import java.util.Comparator;
+import tree.binarytree.BinaryTreeNode;
+import tree.binarytree.LinkedBinaryTreeNode;
+
+public class LinkedBinarySearchTreeNode<E> implements BinarySearchTreeNode<E> {
+
+  private final BinaryTreeNode<E> node;
+  private final Comparator<E> comparator;
+
+  public LinkedBinarySearchTreeNode(E data, Comparator<E> comparator) {
+    this.node = new LinkedBinaryTreeNode<>(data);
+    this.comparator = comparator;
+  }
+
+  @Override
+  public BinaryTreeNode<E> search(E target) {
+    BinaryTreeNode<E> curNode = this.node;
+
+    while (curNode != null) {
+      E curNodeData = curNode.getData();
+      if (curNodeData.equals(target)) {
+        return curNode;
+      } else if (comparator.compare(curNodeData, target) > 0) {
+        curNode = curNode.getLeftSubTree();
+      } else {
+        curNode = curNode.getRightSubTree();
+      }
+    }
+
+    return null;
+  }
+
+  @Override
+  public void insert(E data) {
+    if (data == null) {
+      return;
+    }
+
+    BinaryTreeNode<E> curNode = this.node;
+    BinaryTreeNode<E> parentNode = null;
+
+    while (curNode != null) { // 저장할 위치를 찾는다.
+      E curNodeData = curNode.getData();
+      if (data == curNodeData) { // 중복저장 허용 안함
+        return;
+      }
+
+      parentNode = curNode;
+      if (comparator.compare(curNodeData, data) > 0) {
+        curNode = curNode.getLeftSubTree();
+      } else {
+        curNode = curNode.getRightSubTree();
+      }
+    }
+
+    BinaryTreeNode<E> newNode = new LinkedBinaryTreeNode<>(data);
+    if (comparator.compare(parentNode.getData(), data) > 0) { // 크기를 비교해서 원하는 위치에 저장한다.
+      parentNode.setLeftSubTree(newNode);
+    } else {
+      parentNode.setRightSubTree(newNode);
+    }
+  }
+}

yoonexample/src/main/java/sort/RadixSort.java

@@ -28,9 +28,9 @@ public void sort(int[] array, int maxLength) {
       }
 
       // 버킷 수 만큼 반복
+      int arrayIndex = 0;
       for (int j = 0; j < BUCKET_NUM; j++) {
         // 버킷에 저장되어 있는 것을 순서대로 꺼내서 다시 array에 저장
-        int arrayIndex = 0;
         while (!buckets[j].isEmpty()) {
           array[arrayIndex++] = buckets[j].dequeue();
         }

yoonexample/src/test/java/search/binarysearchtree/BinarySearchTreeNodeTest.java

@@ -0,0 +1,40 @@
+package search.binarysearchtree;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Comparator;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import tree.binarytree.BinaryTreeNode;
+
+class BinarySearchTreeNodeTest {
+
+  @Test
+  @DisplayName("이진_탐색_트리_테스트")
+  void 이진_탐색_트리_테스트() {
+    BinarySearchTreeNode<Integer> bstRoot = new LinkedBinarySearchTreeNode<>(5, (Comparator
+        .comparingInt(o -> o)));
+    BinaryTreeNode<Integer> searchNode;
+
+    bstRoot.insert(1);
+    bstRoot.insert(6);
+    bstRoot.insert(2);
+    bstRoot.insert(8);
+    bstRoot.insert(3);
+    bstRoot.insert(9);
+
+    searchNode = bstRoot.search(1);
+    assertThat(searchNode).isNotNull();
+    assertThat(searchNode.getData()).isEqualTo(1);
+
+    searchNode = bstRoot.search(4);
+    assertThat(searchNode).isNull();
+
+    searchNode = bstRoot.search(6);
+    assertThat(searchNode).isNotNull();
+    assertThat(searchNode.getData()).isEqualTo(6);
+
+    searchNode = bstRoot.search(7);
+    assertThat(searchNode).isNull();
+  }
+}