feat: menambahkan contoh dari quick sorting (bellshade#166)

slowy07 · web-flow · commit 25703b2c15d7 · 2023-04-03T07:25:48.000Z
diff --git a/src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java b/src/main/java/algorithm/datastructure/Sorting/AlgoritmaSorting.java
@@ -0,0 +1,16 @@
+package algorithm.datastructure.Sorting;
+
+import java.util.Arrays;
+import java.util.List;
+
+// interface untuk algoritma Sorting
+public interface AlgoritmaSorting {
+  <T extends Comparable<T>> T[] sorting(T[] tidakTersorting);
+
+  @SuppressWarnings("unchecked")
+  default <T extends Comparable<T>> List<T> sorting(List<T> tidakTersorting) {
+    return Arrays.asList(
+      sorting(tidakTersorting.toArray((T[]) new Comparable[tidakTersorting.size()]))
+    );
+  }
+}
diff --git a/src/main/java/algorithm/datastructure/Sorting/QuickSort.java b/src/main/java/algorithm/datastructure/Sorting/QuickSort.java
@@ -0,0 +1,66 @@
+package algorithm.datastructure.Sorting;
+
+import static algorithm.datastructure.Sorting.SortingUtilites.*;
+
+/**
+ * salah satu algoritma sorting tercepat adalah quick sort
+ * yaitu dengan cara membagi list dengan menggunakan sebuah pivot.
+ * algoritma ini dikenal sebagai partition-exchange sort atau sorting
+ * pergantian pembagi.
+ * dalam perakteknya adalah yang tercepat dari berbagai algoritma
+ * pengurutan dengan perbandingan, seperti merge sort atau heap sort
+ * melakukan proses langsung pada input (in-place) dengan sedikit
+ * tambahan memori. bekerja dengan baik pada berbagai jenis input
+ * data (seperti angka dan karakter).
+ */
+
+class QuickSort implements AlgoritmaSorting {
+  // method untuk implementasi dari generic quick sorting
+  @Override
+  public <T extends Comparable<T>> T[] sorting(T[] array) {
+    lakukanSorting(array, 0, array.length - 1);
+    return array;
+  }
+
+  // fungsi fungsi proses dari sorting
+  private static <T extends Comparable<T>> void lakukanSorting(T[] array, int kiri, int kanan) {
+    if (kiri < kanan) {
+      int pivot = partisiAcak(array, kiri, kanan);
+      lakukanSorting(array, kiri, pivot - 1);
+      lakukanSorting(array, pivot, kanan);
+    }
+  }
+  // acak array untuk menghindari urutan yang pda dasarnya
+  // sudah di order
+  private static <T extends Comparable<T>> int partisiAcak(
+    T[] array,
+    int kiri,
+    int kanan
+  ) { 
+    int indeksAcak = kiri + (int)(Math.random() * (kanan - kiri + 1));
+    swap(array, indeksAcak, kanan);
+    return partisi(array, kiri, kanan);
+  }
+
+  private static <T extends Comparable<T>> int partisi(T[] array, int kiri, int kanan) {
+    int mid = (kiri + kanan) >>> 1;
+    T pivot = array[mid];
+
+    while (kiri <= kanan) {
+      while (lebihKecil(array[kiri], pivot)) {
+        ++kiri;
+      }
+      while (lebihKecil(pivot, array[kanan])) {
+        --kanan;
+      }
+      if (kiri <= kanan) {
+        swap(array, kiri, kanan);
+        ++kiri;
+        --kanan;
+      }
+    }
+    return kiri;
+  }
+}
+
+
diff --git a/src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java b/src/main/java/algorithm/datastructure/Sorting/SortingUtilites.java
@@ -0,0 +1,67 @@
+package algorithm.datastructure.Sorting;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+final class SortingUtilites {
+  public static <T> void swap(T[] array, int i, int j) {
+    T temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+
+  // membandingkan dua elemen untuk melihat apakah
+  // yang pertama lebih kecil daripada yang kedua
+  public static <T extends Comparable<T>> boolean lebihKecil(T elemenPertama, T elemenKedua) {
+    return elemenPertama.compareTo(elemenKedua) < 0;
+  }
+
+  // membandingkan dua  elemen untuk melihat apakah
+  // yang pertama lebih besar dari yang kedua
+  public static <T extends Comparable<T>> boolean lebihBesar(T elemenPertama, T elemenKedua) {
+    return elemenPertama.compareTo(elemenKedua) > 0;
+  }
+
+  // membandingkan dua elemen untuk melihat apakah
+  // elemen pertama lebih besar atau sama dengan
+  // elemen kedua
+  static <T extends Comparable<T>> boolean lebihBesarAtauSama(T elemenPertama, T elemenKedua) {
+    return elemenPertama.compareTo(elemenKedua) >= 0;
+  }
+
+  static void print(List<?> listUntukPrint) {
+    String hasil = listUntukPrint.stream()
+      .map(Object::toString)
+      .collect(Collectors.joining(" "));
+    System.out.println(hasil);
+  }
+
+  static <T> void print(T[] array) {
+    System.out.println(Arrays.toString(array));
+  }
+
+  public static <T extends Comparable<T>> void flip(T[] array, int kiri, int kanan) {
+    while (kiri <= kanan) {
+      swap(array, kiri++, kanan++);
+    }
+  }
+
+  public static <T extends Comparable<T>> boolean telahDisorting(T[] array) {
+    for (int i = 1; i < array.length; i++) {
+      if (lebihKecil(array[i], array[i - 1])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public static <T extends Comparable<T>> boolean telahDisorting(List<T> list) {
+    for (int i = 1; i < list.size(); i++) {
+      if (lebihKecil(list.get(i), list.get(i - 1))) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
