STRUKTUR DATA - PRAKTIKUM 2

Tugas Praktikum 2 Struktur Data-Sorting

Nama : Yoga Ilham Rakasiwi

NIM : 16.MI.0010

Manajemen Informatika 2017/2018

Yo watsappp, kembali ke blog gue. Untuk pembahasan yang kedua, kali ini saya akan menjelaskan tentang struktur data sorting. Ya langsung saja inilah contoh-contohnya.

ALGORITMA SORTING
Pada Algoritma Sorting terdapat banyak metode. Beberapa metode yang ada ialah, Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort, Shell Sorting, dan masih banyak lagi. Nah, pada kesempatan ini akan dibahas tiga metode sederhana sorting yaitu Bubble Sort, Selection Sort, dan Insertion Sort.

ALGORITMA BUBBLE SORT
Metode gelembung (bubble sort) sering juga disebut dengan metode penukaran (exchange sort) adalah metode yang mengurutkan data dengan cara membandingkan masing-masing elemen, kemudian melakukan penukaran bila perlu. Metode ini mudah dipahami dan diprogram, tetapi bila dibandingkan dengan metode lain yang akan kita pelajari, metode ini merupakan metode yang paling tidak efisien.
Bubble Sort merupakan salah satu metode sorting yang cukup mudah untuk dipelajari.
Kenapa mudah? Karena, pada dasarnya Bubble Sort hanya melakukan pemindahan value dari kiri ke kanan untuk Ascending dan dari kanan ke kiri untuk Descending. Seperti nama metodenya yakni, "Bubble Sort" yang berarti menggelembungkan. "Apa yang digelembungkan?" value yang ingin di sorting.

Sebelum masuk ke program, berikut syarat dan langkah-langkah pada metode Bubble Sort :
1. Jumlah iterasi sama dengan banyaknya bilangan dikurang 1.
2. Setiap iterasi, jumlah pertukaran bilangannya sama dengan banyaknya bilangan.
3. Dalam Bubble Sort, walaupun deretan bilangan tersebut sudah ter-sorting maka, proses sorting akan tetap dilakukan.
4. Tidak ada perbedaan cara untuk Bubble Sort Ascending dan Descending.
Apa itu iterasi?, sebenarnya iterasi ialah proses yang dilakukan untuk men-sorting 1 buah bilangan atau dengan kata lain, iterasi bisa juga disebut dengan proses.
Sekarang saatnya untuk contoh kasus. Pada contoh kasus ini, saya akan menjelaskan untuk kasus Ascending dan Descending.

Ascending
Berikut diberikan sebuah deretan bilangan seperti berikut:
5, 12, 3, 19, 1, 47
Langkah Bubble Sort:
Iterasi 1:
5, 12, 3, 19, 1, 47 --> Tidak ada pertukaran. (5 < 12 == true)
5, 3, 12, 19, 1, 47 --> Ada pertukaran. (12 < 3 == false)
5, 3, 12, 19, 1, 47 --> Tidak ada pertukaran. (12 < 19 == true)
5, 3, 12, 1, 19, 47 --> Ada pertukaran. (19 < 1 == false)
5, 3, 12, 1, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Iterasi 2:
3, 5, 12, 1, 19, 47 --> Ada petukaran. (5 < 3 == false)
3, 5, 12, 1, 19, 47 --> Tidak ada pertukaran. (5 < 12 == true)
3, 5, 1, 12, 19, 47 --> Ada pertukaran. (12 < 1 == false)
3, 5, 1, 12, 19, 47 --> Tidak ada pertukaran. (12 < 19 == true)
3, 5, 1, 12, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Iterasi 3:
3, 5, 1, 12, 19, 47 --> Tidak ada pertukaran. (3 < 5 == true)
3, 1, 5, 12, 19, 47 --> Ada pertukaran. (5 < 1 == false)
3, 1, 5, 12, 19, 47 --> Tidak ada pertukaran. (5 < 12 == true)
3, 1, 5, 12, 19, 47 --> Tidak ada pertukaran. (12 < 19 == true)
3, 1, 5, 12, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Iterasi 4:
1, 3, 5, 12, 19, 47 --> Ada pertukaran. (3 < 1 == false)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (3 < 5 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (5 < 12 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (12 < 19 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Iterasi 5:
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (1 < 3 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (3 < 5 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (5 < 12 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (12 < 19 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Iterasi 6:
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (1 < 3 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (3 < 5 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (5 < 12 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (12 < 19 == true)
1, 3, 5, 12, 19, 47 --> Tidak ada pertukaran. (19 < 47 == true)
Jadi, hasil akhir deretan bilangan diatas setelah di Bubble Sort secara Ascending ialah
1, 3, 5, 12, 19, 47

Berikut contoh programnya :

package strukturdata.jobsheet2;

import java.util.Arrays;

public class bubbleshortasc {

public static void main(String[] args) {

// variable

int[] bilangan = {5, 12, 3, 19, 1, 47};

// Tampilkan Bilangan

System.out.println("Bilangan sebelum di sorting Bubble Sort : "+Arrays.toString(bilangan));

// Proses Bubble Sort

System.out.println("\nProses Bubble Sort secara Ascending:");

for(int a = 0; a < bilangan.length; a++) {

// Tampilkan proses Iterasi

System.out.println("Iterasi "+(a+1));

for(int b = 0; b < bilangan.length-1; b++) { if(bilangan[b] > bilangan[b+1]) {

// proses pertukaran bilangan

int temp = bilangan[b];

bilangan[b] = bilangan[b+1];

bilangan[b+1] = temp;

}

// Tampilkan proses pertukaran tiap iterasi

System.out.println(Arrays.toString(bilangan));

}

System.out.println();

}

// Tampilkan hasil akhir

System.out.println("Hasil akhir setelah di sorting: "+Arrays.toString(bilangan));

}

Menggunakan NetBeans :

Run :

Descending
Masih menggunakan deretan bilangan yang seperti contoh di atas.
5, 12, 3, 19, 1, 47
Langkah Bubble Sort:
Iterasi 1:
12, 5, 3, 19, 1, 47 --> Ada pertukaran. (5 > 12 == false)
12, 5, 3, 19, 1, 47 --> Tidak ada pertukaran. (5 > 3 == true)
12, 5, 19, 3, 1, 47 --> Ada pertukaran. (3 > 19 == false)
12, 5, 19, 3, 1, 47 --> Tidak ada pertukaran. (3 > 1 == true)
12, 5, 19, 3, 47, 1 --> Ada pertukaran. (1 > 47 == false)
Iterasi 2:
12, 5, 19, 3, 47, 1 --> Tidak ada pertukaran. (12 > 5 == true)
12, 19, 5, 3, 47, 1 --> Ada pertukaran. (5 > 19 == false)
12, 19, 5, 3, 47, 1 --> Tidak ada pertukaran. (5 > 3 == true)
12, 19, 5, 47, 3, 1 --> Ada pertukaran. (3 > 47 == false)
12, 19, 5, 47, 3, 1 --> Tidak ada pertukaran. (3 > 1 == true)
Iterasi 3:
19, 12, 5, 47, 3, 1 --> Ada pertukaran. (12 > 19 == false)
19, 12, 5, 47, 3, 1 --> Tidak ada pertukaran. (12 > 5 == true)
19, 12, 47, 5, 3, 1 --> Ada pertukaran. (5 > 47 == false)
19, 12, 47, 5, 3, 1 --> Tidak ada pertukaran. (5 > 3 == true)
19, 12, 47, 5, 3, 1 --> Tidak ada pertukaran. (3 > 1 == true)
Iterasi 4:
19, 12, 47, 5, 3, 1 --> Tidak ada pertukaran. (19 > 12 == true)
19, 47, 12, 5, 3, 1 --> Ada pertukaran. (12 > 47 == false)
19, 47, 12, 5, 3, 1 --> Tidak ada pertukaran. (12 > 5 == true)
19, 47, 12, 5, 3, 1 --> Tidak ada pertukaran. (5 > 3 == true)
19, 47, 12, 5, 3, 1 --> Tidak ada pertukaran. (3 > 1 == true)
Iterasi 5:
47, 19, 12, 5, 3, 1 --> Ada pertukaran. (19 > 47 == false)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (19 > 12 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (12 > 5 ==true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (5 > 3 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (3 > 1 == true)
Iterasi 6:
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (47 > 19 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (19 > 12 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (12 > 5 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (5 > 3 == true)
47, 19, 12, 5, 3, 1 --> Tidak ada pertukaran. (3 > 1 == true)

Jadi, hasil akhir deretan bilangan diatas setelah di Bubble Sort secara Descending ialah
47, 19, 12, 5, 3, 1

Berikut contoh programnya :

package strukturdata.jobsheet2;
import java.util.Arrays;
public class bubblesortdesc {
public static void main(String[] args) {
// Variable
int[] bilangan = {5, 12, 3, 19, 1, 47};

// Tampilkan bilangan
System.out.println("Bilangan Sebelum di sorting Bubble Sort : "+Arrays.toString(bilangan));

// Proses Bubble Sort
System.out.println("\nProses Bubble Sort secara Descanding:");
for(int a = 0; a < bilangan.length; a++) {
// Tampilkan proses Iterasi
System.out.println("Iterasi "+(a+1));
for(int b = 0; b < bilangan.length-1; b++) {
if(bilangan[b] < bilangan[b+1]) {
// proses pertukaran bilangan
int temp = bilangan[b];
bilangan[b] = bilangan[b+1];
bilangan[b+1] = temp;
}


// Tampilkan proses pertukaran tiap iterasi
System.out.println(Arrays.toString(bilangan));
}
System.out.println();
}


// Tampilkan hasil akhir
System.out.println("Hasil akhir setelah di sorting: "+Arrays.toString(bilangan));
}
}

Menggunakan NetBeans :

Run :

Selection Sort
Selection Sort merupakan salah satu metode pengurutan yang memiliki algoritma yang cukup gampang dalam penulisan coding-nya. Dibanding Bubble Sort, Selection Sort jelas lebih baik dari segi kecepatan proses pengurutannya. Karena, Inti dari algoritma Selection Sort ialah mencari nilai yang paling kecil(Jika Ascending) atau nilai yang paling besar(Jika Descending) di urutan Data berikutnya. Untuk lebih jelasnya saya beri contoh kasus seperti berikut ini.
Data : 13 9 15 2 3 1
Proses Selection Sort (Ascending)
Iterasi 1 :
13 9 15 2 3 1 → (Apakah 13 nilai yang paling kecil?)
1 9 15 2 3 13 → (Tidak. 13 ditukar dengan 1)
Iterasi 2 :
1 9 15 2 3 13 → (Apakah 9 nilai yang paling kecil?)
1 2 15 9 3 13 → (Tidak. 9 ditukar dengan 2)
Iterasi 3 :
1 2 15 9 3 13 → (Apakah 15 nilai yang paling kecil?)
1 2 3 9 15 13 → (Tidak. 15 ditukar dengan 3)
Iterasi 4 :
1 2 3 9 15 13 → (Apakah 9 nilai yang paling kecil?)
1 2 3 9 15 13 → (Iya)
Iterasi 5 :
1 2 3 9 15 13 → (Apakah 15 nilai yang paling kecil?)
1 2 3 9 13 15 → (Tidak. 15 ditukar dengan 13)
Data Setelah di sorting ialah sebagai berikut :
Data : 1 2 3 9 13 15

Berikut contoh programnya :

package strukturdata.jobsheet2;
import java.util.Scanner;
public class selectionsort
{
public static void main(String[] args)
{
// Buat Objek Scanner
Scanner scan = new Scanner(System.in);
// Input jumlah Data
System.out.print("Masukkan jumlah Data : "); int jlh_data = scan.nextInt();
// Input nilai tiap Data
int[] data = new int[jlh_data];
System.out.println();
for(int x = 0; x < jlh_data; x++)
{
System.out.print("Input nilai Data ke-"+(x+1)+" : ");
data[x] = scan.nextInt();
}
// Tampilkan Data Sebelum di sorting
System.out.println();
System.out.print("Data Sebelum di Sorting : ");
for(int x = 0; x < jlh_data; x++)
System.out.print(data[x]+" ");

// Proses Selection Sort
System.out.println("\n\nProses Selection Sort");
for(int x = 0; x < jlh_data-1; x++)
{
System.out.println("Iterasi ke-"+(x+1)+" : ");
for(int y = 0; y < jlh_data; y++)
System.out.print(data[y]+" ");
System.out.println(" Apakah Data "+data[x]+" sudah benar pada urutannya?");
boolean tukar = false;
int index = 0;
int min = data[x];
String pesan = " Tidak Ada Pertukaran";
for(int y = x+1; y < jlh_data; y++)
{
if(min > data[y])
{
tukar = true;
index = y;
min = data[y];
}
}
if(tukar == true)
{
// Pertukaran Data
pesan = " Data "+data[x]+" ditukar dengan Data "+data[index];
int temp = data[x];
data[x] = data[index];
data[index] = temp;
}
for(int y = 0; y < jlh_data; y++)
System.out.print(data[y]+" ");

System.out.println(pesan+"\n");
}
// Tampilkan Data Setelah di Sorting
System.out.print("Data Setelah di Sorting : ");
for(int x = 0; x < jlh_data; x++)
System.out.print(data[x]+" ");
}
}

Menggunakan NetBeans :

Run :

Penjelasan Algoritma Selection Sort:
1.) Jumlah Iterasi untuk Selection Sort ialah berjumlah sebesar Jumlah Data – 1. Untuk kasus diatas, Jumlah Datanya ialah 6. Maka, jumlah Iterasinya ialah sebesar 6 – 1 = 5.
2.) Proses pertukaran Data dimulai dari Data Pertama sampai Data Terakhir dengan cara membandingkan Data ke-n dan cari nilai yang paling kecil di sisi kanan nilai n.
3.) Keterangan bahwa nilai Data yang sudah di tukar(nilai yang paling kecil) tidak akan dibandingkan lagi untuk proses iterasi berikutnya. Berikut ilustrasi lengkapnya untuk kasus di atas.

Insertion Sort Ascending
“Metode Pengurutan kok banyak banget sih? Padahal dari segi logika untuk melakukan pengurutan seharusnya mudah tinggal buat saja looping dari data pertama sampai data terakhir, kemudian di bloknya ada statement pengkondisian jika data lebih besar atau lebih kecil maka tukar.” Ya, dari segi logika memang semudah itu namun, dari segi algoritma itu berbeda. Seperti pada cara sorting sebelumnya, Bubble Sort dan Selection Sort. Kedua metode itu memang sama – sama untuk sorting namun, kalau Anda lihat proses algoritmanya itu jelas berbeda antara Bubble Sort dan Selection Sort.
“Memangnya seberapa penting sih algoritma itu?” Yah, jelas sangat penting. Proses Sorting itu tidak akan tampak perbedaannya jika data yang Anda sorting itu masih sedikit. Bagaimana jika yang Anda sorting Data perusahaan dengan jumlah data yang bisa beribu – ribu banyaknya bahkan berjuta – juta. Apa mau si user menunggu waktu 1 jam lebih atau 1 harian penuh hanya untuk menunggu proses sorting selesai?, sementara di sisi lain dia bisa mendapatkan hal yang lebih baik dari itu yakni cukup 10 menit data akan terurut dengan benar. Nah, di sinilah pentingnya dari proses Algoritma. Tujuannya sama – sama untuk mengurutkan namun, dari segi kecepatan algoritma jelas berbeda.
Insertion Sort merupakan metode pengurutan dimana langkah – langkahnya ialah membandingkan dari data kedua ke data pertama (Data-N <==> Data-N-1). Berbeda dengan Bubble Sort dimana, proses perbandingannya dimulai dari Data Pertama sampai Data Terakhir. Untuk lebih jelasnya langsung masuk ke contoh kasus berikut.
Data : 12 9 3 20 30 1
Proses Insertion Sort (Ascending)
Iterasi 1:
12 9 3 20 30 1 → (Bandingkan Data 9 dengan 12)
9 12 3 20 30 1 → (Tukar Data 9 dengan 12)
Iterasi 2:
9 12 3 20 30 1 → (Bandingkan Data 3 dengan 12)
9 3 12 20 30 1 → (Tukar 3 dengan 12. Bandingkan 3 dengan 9)
3 9 12 20 30 1 → (Tukar 3 dengan 9)
Iterasi 3:
3 9 12 20 30 1 → (Bandingkan 20 dengan 12)
3 9 12 20 30 1 → (Tidak ada pertukaran)
Iterasi 4:
3 9 12 20 30 1 → (Bandingkan 30 dengan 20)
3 9 12 20 30 1 → (Tidak ada pertukaran)
Iterasi 5:
3 9 12 20 30 1 → (Bandingkan 1 dengan 30)
3 9 12 20 1 30 → (Tukar 1 dengan 30. Bandingkan 1 dengan 20)
3 9 12 1 20 30 → (Tukar 1 dengan 20. Bandingkan 1 dengan 12)
3 9 1 12 20 30 → (Tukar 1 dengan 12. Bandingkan 1 dengan 9)
3 1 9 12 20 30 → (Tukar 1 dengan 9. Bandingkan 1 dengan 3)
1 3 9 12 20 30 → (Tukar 1 dengan 3)

Berikut contoh programnya :

package strukturdata.jobsheet2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Random;
public class insertionsort
{
public static void main(String[] args) throws IOException
{
//objek bufferedReader
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
//input jumlah data
System.out.print("Masukkan jumlah data : ");
int jlh_data = Integer.parseInt(dataIn.readLine());
//Array Data untuk menampung nilai data
int[] data = new int[jlh_data];
//menu pengisian data
System.out.println("\nMenu Pengisian Data");
System.out.println("1. Di input oleh user");
System.out.println("2. Di input oleh program");
System.out.print("Pilihan : ");
int isi_data = Integer.parseInt(dataIn.readLine());
switch (isi_data)
{
case 1 : //Pengisian oleh si user
System.out.println();
for(int a = 0; a < jlh_data; a++)
{
System.out.print("Data ke-"+(a+1)+" : ");
data[a] = Integer.parseInt(dataIn.readLine());
}
break;
case 2 : //Pengisian data oleh program --> di isi secara acak
System.out.println();
for(int a = 0; a < jlh_data; a++)
data[a] = new Random().nextInt(201);
// Tampilkan Data yang di isi oleh program
System.out.print("Data : ");
for(int a = 0; a < jlh_data; a++)
System.out.print(data[a]+" ");
break;
default : System.out.println("\nPilihan tidak tersedia");
}
//Proses Insertion Sort
System.out.println("\nProses Insertion Sort ");
for(int a = 0; a < jlh_data-1; a++)
{
System.out.println("Iterasi "+(a+1));
for(int b = 0; b < jlh_data; b++)
System.out.print(data[b]+"\t");
System.out.print(" --> Bandingkan "+data[a+1]+" dengan "+data[a]);
for(int b = a+1; b > 0; b--)
{
String pesan = " --> Tidak Ada Pertukaran";
if(data[b] < data[b-1])
{
pesan = " --> "+data[b]+" tukar posisi dengan "+data[b-1];
//proses pertukaran
int temp = data[b];
data[b] = data[b-1];
data[b-1] = temp;
System.out.println();
for(int c = 0; c < jlh_data; c++)
System.out.print(data[c]+"\t");
System.out.print(pesan);
}
else
{
System.out.println();
for(int c = 0; c < jlh_data; c++)
System.out.print(data[c]+"\t");
System.out.print(pesan);
break;
}
}
System.out.println("\n");
}
//Tampilkan hasil Akhir
System.out.print("\nData setelah di Sorting : ");
for(int a = 0; a < jlh_data; a++)
System.out.print(data[a]+" ");
}
}

Menggunakan NetBeans :

Run :

Penjelasan Proses Insertion Sort (Ascending)
1.) Dalam Insertion Sort jumlah iterasi ialah sebanyak jumlah data – 1.
Untuk kasus diatas, Jumlah Data ialah 6 maka, jumlah iterasinya ialah 6 – 1 = 5. Dan jumlah iterasi tersebut harus terpenuhi walaupun Data sudah terurut.
2.) Setiap Iterasi memiliki proses dan jumlah proses tersebut tidak bisa ditentuin karena, proses akan berhenti jika Data sudah terurut. Bisa Anda lihat pada iterasi ke-3 dan ke-4. Pada iterasi 3 dan 4 proses pengecekannya cuma sekali namun, karena Data yang di cek memang sudah terurut dengan benar maka, proses pengecekan berhenti dan lanjut ke iterasi berikutnya.
3.) Untuk iterasi ke-1, Proses perbandingan dimulai dari Data ke-2 dengan Data ke-1 (9 <==> 12). Karena, 9 < 12 maka, 9 tukar posisi dengan 12.
4.) Untuk iterasi ke-2, Proses perbandingan dimulai dari Data ke-3 dengan Data ke-2 (3 <==> 12). Karena, 3 < 12 maka,3 tukar dengan 12. Selanjutnya, bandingkan lagi 3 dengan 9 (3 <==> 9). Karena 3 < 9 maka, 3 tukar dengan 9.
5.) Untuk iterasi ke-3, Proses perbandingan dimulai dari Data ke-4 dengan Data ke-3 (20 <==> 12). Karena, 20 > 12 maka, tidak ada pertukaran. Posisi tetap tidak ada perubahan.
6.) Untuk iterasi ke-4, Proses perbandingan dimulai dari Data ke-5 dengan Data ke-4 (30 <==> 20). Karena, 30 > 20 maka, tidak ada pertukaran. Posisi tetap tidak ada perubahan.
7.) Untuk iterasi ke-5, Proses perbandingan dimulai dari Data ke-6 dengan Data ke-5 (1 <==> 30). Karena, 1 < 30 maka, 1 tukar posisi dengan 30. Selanjutnya, bandingkan lagi 1 dengan 20 (1 <==> 20). Karena, 1 < 20 maka, 1 tukar posisi dengan 20. Selanjutnya, bandingkan lagi 1 dengan 12 (1 <==> 12). Karena, 1 < 12 maka, 1 tukar posisi dengan 12. Kemudian, bandingkan lagi antara 1 dengan 9 (1 <==> 9). Karena, 1 < 9 maka, 1 tukar posisi dengan 9. Berikutnya, bandingkan lagi 1 dengan 3 (1 <==> 3). Karena, 1 < 3 maka, 1 tukar posisi dengan 3.
Data setelah disort adalah seperti berikut.
Data : 1 3 9 12 20 30
Bagaimana mudahkan? Konsepnya hampir sama seperti Bubble Sort hanya saja di Insertion Sort proses dimulai dari Data kedua (Data-N+1) dan di cek satu per satu ke Data sebelumnya (Data-N-1). Selain itu, prosesnya juga berbeda antara Bubble Sort dan Insertion Sort. Kalau di Bubble Sort jumlah proses tiap iterasinya selalu dikurang 1 sementara di Insertion Sort jumlah prosesnya akan terus bertambah apabila Data tersebut masih bisa ditukar.

Insertion Sort Descending

Berikut contoh programnya :

package strukturdata.jobsheet2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class tugas
{
public static void main(String[] args) throws IOException
{
BufferedReader dataIn = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Masukkan Jumlah Data : ");
int jlh_data = Integer.parseInt(dataIn.readLine());
int[] data = new int[jlh_data];
System.out.println("\nMenu Pengisian Data");
System.out.println("1. Urut Ascending");
System.out.println("2. Urut Descending");
System.out.print("Pilihan : ");
int isi_data = Integer.parseInt(dataIn.readLine());
switch(isi_data)
{
case 1 : //pengisian datta urut ascending
System.out.println();
for(int a = 0; a < jlh_data; a++)
{
System.out.print("Data ke-"+(a+1)+" : ");
data[a] = Integer.parseInt(dataIn.readLine());
}
break;
case 2 : //pengisian data urut descending
System.out.println();
for(int a = 0; a < jlh_data; a++)
{
System.out.print("Data ke-"+(a+1)+" : ");
data[a] = Integer.parseInt(dataIn.readLine());
}
break;
default : System.out.println("\nPilihan tidak tersedia");
}
//proses insertion sort
System.out.println("\nProses Insertion Sort");
for(int a = 0; a < jlh_data-1; a++)
{
System.out.println("Iterasi "+(a+1));
for(int b = 0; b < jlh_data; b++)
System.out.print(data[b]+"\t");
System.out.print(" --> Bandingkan "+data[a+1]+" dengan "+data[a]);
for(int b = a+1; b < jlh_data-1; b++)
{
String pesan = " --> Tidak ada pertukaran ";
if(data[b] > data [b+1])
{
pesan = " --> "+data[a]+" tukar posisi dengan "+data[a+1];
//proses pertukaran
int temp = data[a];
data[a] = data[a+1];
data[a+1] = temp;
System.out.println();
for(int c = 0; c < jlh_data; c++)
System.out.print(data[c]+"\t");
System.out.print(pesan);
}
else
{
System.out.println();
for(int c = 0; c < jlh_data; c++)
System.out.print(data[c]+"\t");
System.out.print(pesan);
break;
}
}
System.out.println("\n");
}
//tampilkan hasil sorting
System.out.print("\nData setelah di sorting : ");
for(int a = 0; a < jlh_data; a++)
System.out.print(data[a]+" ");
}
}

Menggunakan NetBeans :