Program pengurutan data dengan Bubble Sort, Insertion Sort, Selection Sort, Heap Sort, Quick Sort, Merge Sort

Kali ini saya akan memposting kuis program sorting java :
Soal :

1. Program akan menanyakan berapa data yang akan di urut
2. Program akan menampilkan isian data sebanyak yang di masukan di no.1
3. Program akan mencetak menu sorting
4. Memilih metode sorting
5. Menapilkan hasil sorting sesuai yang di pilih dari menu.

Tampilan :
Berapa data :
Data ke-0 :
Data ke-1 :
Data ke-2 :
dst
MENU SORTING
1. Bubble Sort
2. Insertion Sort
3. Selection Sort
4. Heap Sort
5. Quick Sort
6. Merge Sort
Pilihannya [1..6] :
Hasil BUBLLE SORT :
1 2 3 4 5 dst...

Penyelesaian :
codingnya sbb :
import java.util.scanner;

public static void main(String[] args) {
        // TODO code application logic here
    int [] array=new int[5];
    int n, i;
    Scanner x=new Scanner(System.in);
    System.out.print("Berapa data : ");
    n=x.nextInt();
    /* mengisi array*/
    for (i=0;i<n;i++){
        Scanner b=new Scanner (System.in);
        System.out.print("Data ke-"+i+" :");
        array[i]=b.nextInt();
        }
        //mencetak menu pilihan operator
    int pilihan;
        System.out.println(" == MENU SORTING == ");
        System.out.println("1. Bubble Sort");
        System.out.println("2. Heap Sort");
        System.out.println("3. Insertion Sort");
        System.out.println("4. Merge Sort");
        System.out.println("5. Quick Sort");
        System.out.println("6. Selection Sort");
        System.out.println("0. Keluar");
        do {
        System.out.print("Pilihan : ");
        Scanner p = new Scanner(System.in);
        pilihan = p.nextInt();
        switch(pilihan){
         //memeriksa pilihan yang dimasukkan  
        case 1 : bubble_srt();
        bubble_srt(array, array.length);  
        System.out.print("Hasil Bubble Sort:\n");
        for (i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
            System.out.println("SELESAI");
            System.out.println("------------------------------------------");
        break;
        case 2 : fnSortHeap();
        for (i = array.length; i > 1; i--) {
            fnSortHeap(array, i - 1);
        }  
        System.out.println("Hasil Heap Sort :\n");
        for (i = 0; i < array.length; i++) {
            System.out.print("  " + array[i]);
        }
        System.out.println(" SELESAI");
        System.out.println("------------------------------------------");
        break;
        case 3 : insertion_srt();
        insertion_srt(array, array.length);
        System.out.print("Hasil Insertion Sort:\n");
        for (i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.println("SELESAI");
        System.out.println("------------------------------------------");
        break;
        case 4 : mergeSort_srt();
        mergeSort_srt(array, 0, array.length - 1);  
        System.out.print("Hasil Merge Sort:\n");
        for (i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.println("SELESAI");
        System.out.println("------------------------------------------");
        break;
        case 5 : quick_srt();
        quick_srt(array, 0, array.length - 1);
        System.out.print("Hasil Quick vSort:\n");
        for (i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.println("SELESAI");
        System.out.println("------------------------------------------");
        break;
        case 6 : selection_srt();
        selection_srt(array, array.length);  
        System.out.print("Hasil Selection Sort:\n");
        for (i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.println("SELESAI");
        System.out.println("------------------------------------------");
        break;
}
} while(pilihan != 0);  
}
           
        private static void bubble_srt(){          
        }
        private static void fnSortHeap(){
     
        }
        private static void insertion_srt(){
             
        }
        private static void mergeSort_srt(){
             
        }
        private static void quick_srt(){
             
        }
        private static void selection_srt(){
     
}
     
public static void bubble_srt(int a[], int n) {
        int i, j, t = 0;
        for (i = 0; i < n; i++) {
            for (j = 1; j < (n - i); j++) {
                if (a[j - 1] > a[j]) {
                    t = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = t;
                }
            }
        }
    }  

public static void fnSortHeap(int array[], int arr_ubound) {
        int i, o;
        int lChild, rChild, mChild, root, temp;
        root = (arr_ubound - 1) / 2;

        for (o = root; o >= 0; o--) {
            for (i = root; i >= 0; i--) {
                lChild = (2 * i) + 1;
                rChild = (2 * i) + 2;
                if ((lChild <= arr_ubound) && (rChild <= arr_ubound)) {
                    if (array[rChild] >= array[lChild]) {
                        mChild = rChild;
                    } else {
                        mChild = lChild;
                    }
                } else {
                    if (rChild > arr_ubound) {
                        mChild = lChild;
                    } else {
                        mChild = rChild;
                    }
                }

                if (array[i] < array[mChild]) {
                    temp = array[i];
                    array[i] = array[mChild];
                    array[mChild] = temp;
                }
            }
        }
        temp = array[0];
        array[0] = array[arr_ubound];
        array[arr_ubound] = temp;
        return;
    }
public static void insertion_srt(int array[], int n) {
        for (int i = 1; i < n; i++) {
            int j = i;
            int B = array[i];
            while ((j > 0) && (array[j - 1] > B)) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = B;
        }
    }  
public static void mergeSort_srt(int array[], int lo, int n) {
        int low = lo;
        int high = n;
        if (low >= high) {
            return;
        }

        int middle = (low + high) / 2;
        mergeSort_srt(array, low, middle);
        mergeSort_srt(array, middle + 1, high);
        int end_low = middle;
        int start_high = middle + 1;
        while ((lo <= end_low) && (start_high <= high)) {
            if (array[low] < array[start_high]) {
                low++;
            } else {
                int Temp = array[start_high];
                for (int k = start_high - 1; k >= low; k--) {
                    array[k + 1] = array[k];
                }
                array[low] = Temp;
                low++;
                end_low++;
                start_high++;
            }
        }
    }  
public static void quick_srt(int array[], int low, int n) {
        int lo = low;
        int hi = n;
        if (lo >= n) {
            return;
        }
        int mid = array[(lo + hi) / 2];
        while (lo < hi) {
            while (lo < hi && array[lo] < mid) {
                lo++;
            }
            while (lo < hi && array[hi] > mid) {
                hi--;
            }
            if (lo < hi) {
                int T = array[lo];
                array[lo] = array[hi];
                array[hi] = T;
            }
        }
        if (hi < lo) {
            int T = hi;
            hi = lo;
            lo = T;
        }
        quick_srt(array, low, lo);
        quick_srt(array, lo == low ? lo + 1 : lo, n);
    }  
public static void selection_srt(int array[], int n) {
        for (int x = 0; x < n; x++) {
            int index_of_min = x;
            for (int y = x; y < n; y++) {
                if (array[index_of_min] < array[y]) {
                    index_of_min = y;
                }
            }
            int temp = array[x];
            array[x] = array[index_of_min];
            array[index_of_min] = temp;
        }
    }  
}  
terima kasih...silahkan di copas!