간단한 정렬 알고리즘 구현

yoonexample/src/main/java/sort/BubbleSort.java

@@ -0,0 +1,19 @@
+package sort;
+
+public class BubbleSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    int length = array.length;
+    int temp;
+    for (int i = 0; i < length - 1; i++) {
+      for (int j = 0; j < length - i - 1; j++) {
+        if (array[j] > array[j + 1]) {
+          temp = array[j];
+          array[j] = array[j + 1];
+          array[j + 1] = temp;
+        }
+      }
+    }
+  }
+}

yoonexample/src/main/java/sort/InsertionSort.java

@@ -0,0 +1,25 @@
+package sort;
+
+public class InsertionSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    int length = array.length;
+    int insertData;
+
+    for (int i = 1; i < length; i++) {
+      insertData = array[i];
+      int j;
+
+      for (j = i - 1; j >= 0; j--) { // 정렬된 배열의 뒷부분 부터 비교해서 삽입위치 탐색
+        if (array[j] > insertData) { // 삽입할 데이터가 작으면
+          array[j + 1] = array[j]; // 위치 변경
+        } else {
+          break; // 해당 위치에 삽입되어야 하므로 탈출
+        }
+      }
+
+      array[j + 1] = insertData;
+    }
+  }
+}

yoonexample/src/main/java/sort/SelectionSort.java

@@ -0,0 +1,24 @@
+package sort;
+
+public class SelectionSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    int length = array.length;
+    int maxIndex;
+    int temp;
+    for (int i = 0; i < length - 1; i++) {
+      maxIndex = i;
+      for (int j = i + 1; j < length; j++) { // 최솟값 탐색
+        if (array[j] < array[maxIndex]) {
+          maxIndex = j;
+        }
+      }
+
+      // swap
+      temp = array[i];
+      array[i] = array[maxIndex];
+      array[maxIndex] = temp;
+    }
+  }
+}

yoonexample/src/main/java/sort/Sort.java

@@ -0,0 +1,6 @@
+package sort;
+
+public interface Sort {
+
+  void sort(int[] array);
+}

yoonexample/src/test/java/sort/SortTest.java

@@ -0,0 +1,115 @@
+package sort;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+class SortTest {
+
+  long beforeTime;
+  long afterTime;
+
+  @BeforeEach
+  void setUp() {
+    beforeTime = System.currentTimeMillis();
+  }
+
+  @AfterEach
+  void tearDown() {
+    afterTime = System.currentTimeMillis();
+    System.out.println("===========>실행시간(ms): " + (afterTime - beforeTime));
+  }
+
+  @Test
+  @DisplayName("버블_정렬_테스트")
+  void 버블_정렬_테스트() {
+    Sort sort = new BubbleSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  @Test
+  @DisplayName("선택_정렬_테스트")
+  void 선택_정렬_테스트() {
+    Sort sort = new SelectionSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  @Test
+  @DisplayName("삽입_정렬_테스트")
+  void 삽입_정렬_테스트() {
+    Sort sort = new InsertionSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  @Test
+  @DisplayName("힙_정렬_테스트")
+  void 힙_정렬_테스트() {
+    Sort sort = new HeapSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  @Test
+  @DisplayName("병합_정렬_테스트")
+  void 병합_정렬_테스트() {
+    Sort sort = new MergeSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+
+  @Test
+  @DisplayName("퀵_정렬_테스트")
+  void 퀵_정렬_테스트() {
+    Sort sort = new QuickSort();
+
+    // Repeated Test 사용시 각각 실행시간이 찍혀서 어쩔 수 없이 반복 (1억번)
+    for (int i = 0; i < 100_000_000; i++) {
+      int[] actual = {1, 4, 5, 2, 3, 7, 6};
+      int[] expected = {1, 2, 3, 4, 5, 6, 7};
+      sort.sort(actual);
+
+      assertThat(actual).isEqualTo(expected);
+    }
+  }
+}