복잡한 정렬 알고리즘 완료

yoonexample/src/main/java/sort/HeapSort.java

@@ -0,0 +1,27 @@
+package sort;
+
+import heap.ArrayUsefulHeap;
+import heap.UsefulHeap;
+import java.util.Comparator;
+
+public class HeapSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    this.sort(array, ((o1, o2) -> o2 - o1));
+  }
+
+  private void sort(int[] array, Comparator<Integer> comp) {
+    UsefulHeap<Integer> heap = new ArrayUsefulHeap<>(comp);
+
+    // 정렬 대상을 가지고 힙을 구성한다.
+    for (int i : array) {
+      heap.insert(i);
+    }
+
+    // 힙에서 하나씩 꺼내서 정렬된 구조로 반환한다.
+    for (int i = 0; i < array.length; i++) {
+      array[i] = heap.delete();
+    }
+  }
+}

yoonexample/src/main/java/sort/MergeSort.java

@@ -0,0 +1,51 @@
+package sort;
+
+public class MergeSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    mergeSort(array, 0, array.length - 1);
+  }
+
+  private void mergeSort(int[] array, int left, int right) {
+    if (left < right) { // 더 나눌 수 있다면
+      int mid = left + ((right - left) / 2); // https://endorphin0710.tistory.com/112 참조
+
+      mergeSort(array, left, mid);
+      mergeSort(array, mid + 1, right);
+
+      mergeTwoArea(array, left, mid, right);
+    }
+  }
+
+  private void mergeTwoArea(int[] array, int left, int mid, int right) {
+    int[] temp = new int[right + 1];
+    int fIndex = left;
+    int rIndex = mid + 1;
+    int sIndex = left;
+
+    while (fIndex <= mid && rIndex <= right) {
+      if (array[fIndex] <= array[rIndex]) {
+        temp[sIndex] = array[fIndex++];
+      } else {
+        temp[sIndex] = array[rIndex++];
+      }
+
+      sIndex++;
+    }
+
+    if (fIndex > mid) {
+      for (int i = rIndex; i <= right; i++, sIndex++) {
+        temp[sIndex] = array[i];
+      }
+    } else {
+      for (int i = fIndex; i <= mid; i++, sIndex++) {
+        temp[sIndex] = array[i];
+      }
+    }
+
+    for (int i = left; i <= right; i++) {
+      array[i] = temp[i];
+    }
+  }
+}

yoonexample/src/main/java/sort/QuickSort.java

@@ -0,0 +1,38 @@
+package sort;
+
+public class QuickSort implements Sort {
+
+  @Override
+  public void sort(int[] array) {
+    quickSort(array, 0, array.length - 1);
+  }
+
+  private void quickSort(int[] array, int left, int right) {
+    if (left < right) { // 교차되기 전까지
+      int pivot = partition(array, left, right);
+      quickSort(array, left, pivot - 1);
+      quickSort(array, pivot + 1, right);
+    }
+  }
+
+  private int partition(int[] array, int left, int right) {
+    int pivot = array[left];
+    int k = right;
+
+    for (int i = right; i > left; i--) {
+      if (array[i] > pivot) {
+        swap(array, i, k);
+        k--;
+      }
+    }
+
+    swap(array, left, k);
+    return k;
+  }
+
+  private void swap(int[] array, int index1, int index2) {
+    int temp = array[index1];
+    array[index1] = array[index2];
+    array[index2] = temp;
+  }
+}