Sorting

package Code.Sorting;

public class Sorting {

    void bubbleSort(int[] data) {
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data.length; j++) {
                if (data[j] > data[j + 1]) {
                    int tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                }
            }
        }
    }

    void selectionSort(int[] arr) {
        int n = arr.length;

        // Looping untuk iterasi dari elemen pertama hingga elemen kedua terakhir
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i; // Menyimpan indeks elemen minimum

            // Looping untuk mencari elemen minimum dalam bagian belum terurut
            for (int j = i + 1; j < n; j++) {
                // Membandingkan elemen saat ini dengan elemen minimum yang ada
                if (arr[j] < arr[minIndex]) {
                    // Jika ditemukan elemen yang lebih kecil, mengupdate indeks elemen minimum
                    minIndex = j;
                }
            }

            // Swap elemen minimum dengan elemen pertama dalam bagian belum terurut
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

    void insertionSort(int[] array) {
        int n = array.length;

        for (int i = 1; i < n; i++) {
            int currentElement = array[i];
            int j = i - 1;

            /*
             * Memindahkan elemen-elemen yang lebih besar dari currentElement ke posisi
             * setelahnya
             */
            while (j >= 0 && array[j] > currentElement) {
                array[j + 1] = array[j];
                j--;
            }

            // Menempatkan currentElement pada posisi yang tepat dalam bagian terurut
            array[j + 1] = currentElement;
        }
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // Pilih pivot dan lakukan partisi array
            int pivot = partition(arr, low, high);

            // Panggil quickSort rekursif pada dua bagian array yang belum terurut
            quickSort(arr, low, pivot - 1); // Bagian kiri dari pivot
            quickSort(arr, pivot + 1, high); // Bagian kanan dari pivot
        }
    }

    private static int partition(int[] arr, int low, int high) {
        // Ambil elemen pivot (di sini, elemen terakhir)
        int pivot = arr[high];

        // Inisialisasi indeks i dengan nilai kurang dari low
        int i = low - 1;

        // Loop dari low hingga high - 1
        for (int j = low; j < high; j++) {
            // Jika elemen saat ini lebih kecil dari pivot, lakukan swap dan naikkan nilai i
            if (arr[j] < pivot) {
                i++;
                swap(arr, i, j);
            }
        }

        // Letakkan pivot pada posisi yang tepat dengan menukar elemen i + 1 dengan
        // pivot
        swap(arr, i + 1, high);

        // Kembalikan posisi pivot
        return i + 1;
    }

    private static void swap(int[] arr, int i, int j) {
        // Fungsi untuk menukar dua elemen dalam array
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {

    }
}