Merge pull request #27 from Data-Structure-Study/yoonexample

연결리스트 기반 큐 작성

Author: ksundong

yoonexample/src/main/java/deque/Deque.java

@@ -0,0 +1,66 @@
+package deque;
+
+/**
+ * Deque 자료구조의 ADT, 인터페이스
+ *
+ * @param <E> 데이터의 파라미터 타입
+ * @author dion
+ */
+public interface Deque<E> {
+
+  /**
+   * 덱에 저장된 데이터의 개수를 반환합니다.
+   *
+   * @return 데이터의 개수
+   */
+  int size();
+
+  /**
+   * 덱이 비어있는지 여부를 반환합니다.
+   *
+   * @return 덱이 비어있으면 true, 그렇지 않으면 false
+   */
+  boolean isEmpty();
+
+  /**
+   * 덱의 앞부분에 데이터를 추가합니다.
+   *
+   * @param data 저장할 데이터
+   */
+  void addFirst(E data);
+
+  /**
+   * 덱의 뒷부분에 데이터를 추가합니다.
+   *
+   * @param data 저장할 데이터
+   */
+  void addLast(E data);
+
+  /**
+   * 덱의 앞부분에 위치한 데이터를 제거합니다.
+   *
+   * @return 덱의 앞부분에 위치했던 데이터
+   */
+  E removeFirst();
+
+  /**
+   * 덱의 뒷부분에 위치한 데이터를 제거합니다.
+   *
+   * @return 덱의 뒷부분에 위치했던 데이터
+   */
+  E removeLast();
+
+  /**
+   * 덱의 앞부분에 위치한 데이터를 반환합니다.
+   *
+   * @return 덱의 앞부분에 위치한 데이터
+   */
+  E getFirst();
+
+  /**
+   * 덱의 뒷부분에 위치한 데이터를 반환합니다.
+   *
+   * @return 덱의 뒷부분에 위치한 데이터
+   */
+  E getLast();
+}

yoonexample/src/main/java/queue/LinkedListQueue.java

@@ -0,0 +1,63 @@
+package queue;
+
+import exception.EmptyQueueException;
+
+public class LinkedListQueue<E> implements Queue<E> {
+
+  private int size;
+  private Node<E> front;
+  private Node<E> rear;
+
+  @Override
+  public int size() {
+    return this.size;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return this.size == 0;
+  }
+
+  @Override
+  public void enqueue(E data) {
+    Node<E> newNode = new Node<>(data);
+    if (isEmpty()) {
+      this.front = newNode;
+    } else {
+      this.rear.next = newNode;
+    }
+    this.rear = newNode;
+    this.size++;
+  }
+
+  @Override
+  public E dequeue() {
+    if (isEmpty()) {
+      throw new EmptyQueueException();
+    }
+    E retData = this.front.data;
+    this.front = this.front.next;
+    this.size--;
+
+    return retData;
+  }
+
+  @Override
+  public E peek() {
+    if (isEmpty()) {
+      throw new EmptyQueueException();
+    }
+
+    return this.front.data;
+  }
+
+  private static class Node<T> {
+
+    private T data;
+    private Node<T> next;
+
+    public Node(T data) {
+      this.data = data;
+    }
+  }
+}

yoonexample/src/test/java/queue/QueueTest.java

@@ -78,4 +78,74 @@ class QueueTest {
     assertThat(queue.isEmpty()).isTrue();
     assertThat(queue.size()).isEqualTo(0);
   }
+
+  @Test
+  @DisplayName("연결_리스트_기반_큐_생성_테스트")
+  void 연결_리스트_기반_큐_생성_테스트() {
+    Queue<Integer> queue = new LinkedListQueue<>();
+
+    assertThat(queue).isNotNull();
+    assertThat(queue.isEmpty()).isTrue();
+    assertThat(queue.size()).isEqualTo(0);
+  }
+
+  @Test
+  @DisplayName("연결_리스트_기반_큐_생성_테스트")
+  void 연결_리스트_기반_큐_EmptyQueueException_테스트() {
+    Queue<Integer> queue = new LinkedListQueue<>();
+
+    assertThat(queue).isNotNull();
+    assertThat(queue.isEmpty()).isTrue();
+    assertThat(queue.size()).isEqualTo(0);
+    assertThatThrownBy(queue::dequeue).isInstanceOf(EmptyQueueException.class);
+    assertThatThrownBy(queue::peek).isInstanceOf(EmptyQueueException.class);
+  }
+
+  @Test
+  @DisplayName("연결_리스트_기반_큐_데이터_저장_테스트")
+  void 연결_리스트_기반_큐_데이터_저장_테스트() {
+    Queue<Integer> queue = new LinkedListQueue<>();
+
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+    queue.enqueue(4);
+    queue.enqueue(5);
+
+    assertThat(queue).isNotNull();
+    assertThat(queue.isEmpty()).isFalse();
+    assertThat(queue.size()).isEqualTo(5);
+  }
+
+  @Test
+  @DisplayName("연결_리스트_기반_큐_데이터_저장_후_제거_테스트")
+  void 연결_리스트_기반_큐_데이터_저장_후_제거_테스트() {
+    Queue<Integer> queue = new LinkedListQueue<>();
+
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+    queue.enqueue(4);
+    queue.enqueue(5);
+
+    assertThat(queue).isNotNull();
+    assertThat(queue.isEmpty()).isFalse();
+    assertThat(queue.size()).isEqualTo(5);
+    assertThat(queue.peek()).isEqualTo(1);
+    assertThat(queue.dequeue()).isEqualTo(1);
+    assertThat(queue.size()).isEqualTo(4);
+    assertThat(queue.peek()).isEqualTo(2);
+    assertThat(queue.dequeue()).isEqualTo(2);
+    assertThat(queue.size()).isEqualTo(3);
+    assertThat(queue.peek()).isEqualTo(3);
+    assertThat(queue.dequeue()).isEqualTo(3);
+    assertThat(queue.size()).isEqualTo(2);
+    assertThat(queue.peek()).isEqualTo(4);
+    assertThat(queue.dequeue()).isEqualTo(4);
+    assertThat(queue.size()).isEqualTo(1);
+    assertThat(queue.peek()).isEqualTo(5);
+    assertThat(queue.dequeue()).isEqualTo(5);
+    assertThat(queue.isEmpty()).isTrue();
+    assertThat(queue.size()).isEqualTo(0);
+  }
 }