순회가 가능한 이진 트리 구현

yoonexample/src/main/java/tree/binarytree/TraversableBinaryTreeNode.java

@@ -0,0 +1,59 @@
+package tree.binarytree;
+
+/**
+ * 순회한 정보를 반환할 수 있는 이진 트리
+ *
+ * @param <E> 파라미터 타입
+ */
+public interface TraversableBinaryTreeNode<E> {
+
+  /**
+   * 해당 노드에 저장된 데이터를 반환합니다.
+   *
+   * @return 저장된 데이터
+   */
+  E getData();
+
+  /**
+   * 해당 노드의 왼쪽 서브트리를 반환합니다.
+   *
+   * @return 왼쪽 서브트리
+   */
+  TraversableBinaryTreeNode<E> getLeftSubTree();
+
+  /**
+   * 왼쪽 서브트리를 등록합니다.
+   *
+   * @param subTree 대상이 될 노드
+   */
+  void setLeftSubTree(TraversableBinaryTreeNode<E> subTree);
+
+  /**
+   * 해당 노드의 오른쪽 서브트리를 반환합니다.
+   *
+   * @return 오른쪽 서브트리
+   */
+  TraversableBinaryTreeNode<E> getRightSubTree();
+
+  /**
+   * 오른쪽 서브트리를 등록합니다.
+   *
+   * @param subTree 대상이 될 노드
+   */
+  void setRightSubTree(TraversableBinaryTreeNode<E> subTree);
+
+  /**
+   * 전위 순회한 정보를 StringBuilder에 저장합니다.
+   */
+  void preorderTraverse(StringBuilder sb);
+
+  /**
+   * 중위 순회한 정보를 StringBuilder에 저장합니다.
+   */
+  void inorderTraverse(StringBuilder sb);
+
+  /**
+   * 후위 순회한 정보를 StringBuilder에 저장합니다.
+   */
+  void postorderTraverse(StringBuilder sb);
+}

yoonexample/src/main/java/tree/binarytree/TraversableBinaryTreeNodeImpl.java

@@ -0,0 +1,70 @@
+package tree.binarytree;
+
+public class TraversableBinaryTreeNodeImpl<E> implements TraversableBinaryTreeNode<E> {
+
+  private final E data;
+  private TraversableBinaryTreeNode<E> left;
+  private TraversableBinaryTreeNode<E> right;
+
+  public TraversableBinaryTreeNodeImpl(E data) {
+    this.data = data;
+  }
+
+  @Override
+  public E getData() {
+    return this.data;
+  }
+
+  @Override
+  public TraversableBinaryTreeNode<E> getLeftSubTree() {
+    return this.left;
+  }
+
+  @Override
+  public void setLeftSubTree(TraversableBinaryTreeNode<E> subTree) {
+    this.left = subTree;
+  }
+
+  @Override
+  public TraversableBinaryTreeNode<E> getRightSubTree() {
+    return this.right;
+  }
+
+  @Override
+  public void setRightSubTree(TraversableBinaryTreeNode<E> subTree) {
+    this.right = subTree;
+  }
+
+  @Override
+  public void preorderTraverse(StringBuilder sb) {
+    sb.append(this.data.toString());
+    if (this.left != null) {
+      this.left.preorderTraverse(sb);
+    }
+    if (this.right != null) {
+      this.right.preorderTraverse(sb);
+    }
+  }
+
+  @Override
+  public void inorderTraverse(StringBuilder sb) {
+    if (this.left != null) {
+      this.left.inorderTraverse(sb);
+    }
+    sb.append(this.data.toString());
+    if (this.right != null) {
+      this.right.inorderTraverse(sb);
+    }
+  }
+
+  @Override
+  public void postorderTraverse(StringBuilder sb) {
+    if (this.left != null) {
+      this.left.postorderTraverse(sb);
+    }
+    if (this.right != null) {
+      this.right.postorderTraverse(sb);
+    }
+    sb.append(this.data.toString());
+  }
+}

yoonexample/src/test/java/tree/binarytree/TraversableBinaryTreeNodeTest.java

@@ -0,0 +1,103 @@
+package tree.binarytree;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class TraversableBinaryTreeNodeTest {
+
+  @Test
+  @DisplayName("순회_가능한_이진_트리_생성_및_초기화_테스트")
+  void 순회_가능한_이진_트리_생성_및_초기화_테스트() {
+    TraversableBinaryTreeNode<Integer> bt = new TraversableBinaryTreeNodeImpl<>(1);
+
+    assertThat(bt).isNotNull();
+    assertThat(bt.getData()).isEqualTo(1);
+    assertThat(bt.getLeftSubTree()).isNull();
+    assertThat(bt.getRightSubTree()).isNull();
+  }
+
+  @Test
+  @DisplayName("순회_가능한_이진_트리_저장_및_출력_테스트")
+  void 순회_가능한_이진_트리_저장_및_출력_테스트() {
+    TraversableBinaryTreeNode<Integer> bt1 = new TraversableBinaryTreeNodeImpl<>(1);
+    TraversableBinaryTreeNode<Integer> bt2 = new TraversableBinaryTreeNodeImpl<>(2);
+    TraversableBinaryTreeNode<Integer> bt3 = new TraversableBinaryTreeNodeImpl<>(3);
+    TraversableBinaryTreeNode<Integer> bt4 = new TraversableBinaryTreeNodeImpl<>(4);
+
+    bt1.setLeftSubTree(bt2);
+    bt1.setRightSubTree(bt3);
+    bt2.setLeftSubTree(bt4);
+
+    assertThat(bt1).isNotNull();
+    assertThat(bt2).isNotNull();
+    assertThat(bt3).isNotNull();
+    assertThat(bt4).isNotNull();
+    assertThat(bt1.getData()).isEqualTo(1);
+    assertThat(bt2.getData()).isEqualTo(2);
+    assertThat(bt3.getData()).isEqualTo(3);
+    assertThat(bt4.getData()).isEqualTo(4);
+    assertThat(bt1.getLeftSubTree().getData()).isEqualTo(2);
+    assertThat(bt1.getRightSubTree().getData()).isEqualTo(3);
+    assertThat(bt1.getLeftSubTree().getLeftSubTree().getData()).isEqualTo(4);
+    assertThat(bt1.getLeftSubTree().getRightSubTree()).isNull();
+  }
+
+  @Test
+  @DisplayName("순회_가능한_이진_트리_전위_순회_테스트")
+  void 순회_가능한_이진_트리_전위_순회_테스트() {
+    TraversableBinaryTreeNode<Integer> bt1 = new TraversableBinaryTreeNodeImpl<>(1);
+    TraversableBinaryTreeNode<Integer> bt2 = new TraversableBinaryTreeNodeImpl<>(2);
+    TraversableBinaryTreeNode<Integer> bt3 = new TraversableBinaryTreeNodeImpl<>(3);
+    TraversableBinaryTreeNode<Integer> bt4 = new TraversableBinaryTreeNodeImpl<>(4);
+
+    bt1.setLeftSubTree(bt2);
+    bt1.setRightSubTree(bt3);
+    bt2.setLeftSubTree(bt4);
+
+    String expected = "1243";
+    StringBuilder sb = new StringBuilder();
+    bt1.preorderTraverse(sb);
+
+    assertThat(sb.toString()).isEqualTo(expected);
+  }
+
+  @Test
+  @DisplayName("순회_가능한_이진_트리_중위_순회_테스트")
+  void 순회_가능한_이진_트리_중위_순회_테스트() {
+    TraversableBinaryTreeNode<Integer> bt1 = new TraversableBinaryTreeNodeImpl<>(1);
+    TraversableBinaryTreeNode<Integer> bt2 = new TraversableBinaryTreeNodeImpl<>(2);
+    TraversableBinaryTreeNode<Integer> bt3 = new TraversableBinaryTreeNodeImpl<>(3);
+    TraversableBinaryTreeNode<Integer> bt4 = new TraversableBinaryTreeNodeImpl<>(4);
+
+    bt1.setLeftSubTree(bt2);
+    bt1.setRightSubTree(bt3);
+    bt2.setLeftSubTree(bt4);
+
+    String expected = "4213";
+    StringBuilder sb = new StringBuilder();
+    bt1.inorderTraverse(sb);
+
+    assertThat(sb.toString()).isEqualTo(expected);
+  }
+
+  @Test
+  @DisplayName("순회_가능한_이진_트리_후위_순회_테스트")
+  void 순회_가능한_이진_트리_후위_순회_테스트() {
+    TraversableBinaryTreeNode<Integer> bt1 = new TraversableBinaryTreeNodeImpl<>(1);
+    TraversableBinaryTreeNode<Integer> bt2 = new TraversableBinaryTreeNodeImpl<>(2);
+    TraversableBinaryTreeNode<Integer> bt3 = new TraversableBinaryTreeNodeImpl<>(3);
+    TraversableBinaryTreeNode<Integer> bt4 = new TraversableBinaryTreeNodeImpl<>(4);
+
+    bt1.setLeftSubTree(bt2);
+    bt1.setRightSubTree(bt3);
+    bt2.setLeftSubTree(bt4);
+
+    String expected = "4231";
+    StringBuilder sb = new StringBuilder();
+    bt1.postorderTraverse(sb);
+
+    assertThat(sb.toString()).isEqualTo(expected);
+  }
+}