TUGAS STRUKTUR DATA DAN ALGORITMA

SORTING

DISUSUN OLEH
FEMBI REKRISNA GRANDEA PUTRA
M0513019

JURUSAN INFORMATIKA
FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM
UNIVERSITAS SEBELAS MARET
SURAKARTA

MEI 2014
 BAB I
PENDAHULUAN

Sorting atau pengurutan data adalah proses yang sering harus dilakukan dalam
pengolahan data. Sort dalam hal ini diartikan mengurutkan data yang berada dalam suatu
tempat penyimpanan, dengan urutan tertentu baik urut menaik (ascending) dari nilai terkecil
sampai dengan nilai terbesar, atau urut menurun (descending) dari nilai terbesar sampai dengan
nilai terkecil. Sorting adalah proses pengurutan. Berikut ini beberapa metode sorting yaitu:

1. BUBBLE SORT

Bubble sort adalah proses pengurutan sederhana yang bekerja dengan cara berulang
kali membandingkan dua elemen data pada suatu saat dan menukar elemen data yang
urutannya salah. Ide dari bubble sort adalah gelembung air yang akan “mengap ung”
untuk tabel yang terurut menaik (ascending). Elemen bernilai kecil akan “diapungka n”
(ke indeks terkecil), artinya diangkat ke “atas” (indeks terkecil) melalui pertukaran.
Karena algoritma ini melakukan pengurutan dengan cara membandingkan elemen-
elemen data satu sama lain, maka bubble sort termasuk ke dalam jenis algoritma
comparison-based sorting.
2. SELECTION SORT

Algoritma selection sort memilih elemen maksimum/minimum array, lalu menem-

patkan elemen maksimum/minimum itu pada awal atau akhir array (tergantung pada
urutannya ascending/descending). Selanjutnya elemen tersebut tidak disertakan pada
proses selanjutnya. Karena setiap kali selection sort harus membandingkan elemen-
elemen data, algoritma ini termasuk dalam comparison-based sorting. Seperti pada
algoritma bubble sort, proses memilih nilai maksimum/minimum dilakukan pada setiap
pass. Jika array berukuran N, maka jumlah pass adalah N-1.

3. INSERTION SORT

Insertion sort adalah sebuah algoritma pengurutan yang membandingkan dua

elemen data pertama, mengurutkannya, kemudian mengecek elemen data berikutnya satu
persatu dan membandingkannya dengan elemen data yang telah diurutkan. Karena
algoritma ini bekerja dengan membandingkan elemen-elemen data yang akan diurutkan,
algoritma ini termasuk pula dalam comparison-based sort. Ide dasar dari algoritma
insertion sort ini adalah mencari tempat yang “tepat” untuk setiap elemen array, dengan
cara sequential search. Proses ini kemudian menyisipkan sebuah elemen array yang
diproses ke tempatnya yang seharusnya. Proses dilakukan sebanyak N-1 tahapan (dalam
sorting disebut sebagai “pass“), dengan indeks dimulai dari 0.Proses pengurutan dengan
menggunakan algoritma insertion sort dilakukan dengan cara membandingkan data ke-i
(di mana i dimulai dari data ke-2 sampai dengan data terakhir) dengan data berikutnya.
Jika ditemukan data yang lebih kecil maka data tersebut disisipkan ke depan sesuai
dengan posisi yang seharusnya.

4. SHELL SORT
 Metode ini disebut juga dengan metode pertambahan menurun (diminishing
increment). Metode ini dikembangkan oleh Donald L. Shell pada tahun 1959, sehingga
sering disebut dengan metode shell sort. Metode ini mengurutkan data dengan cara
membandingkan suatu data dengan data lain yang memiliki jarak tertentu, kemudian
dilakukan penukaran bila diperlukan. Proses pengurutan dengan metode shell dapat
dijelaskan sebagai berikut: Pertama-tama adalah menentukan jarak mula-mula dari data
yang akan dibandingkan, yaitu N/2. Data pertama dibandingkan dengan data dengan
jarak N/2. Apabila data pertama lebih besar dari data ke N/2 tersebut maka kedua data
tersebut ditukar. Kemudian data kedua dibandingkan dengan jarak yang sama yaitu N/2.
Demikian seterusnya sampai seluruh data dibandingkan sehingga semua data ke-j selalu
lebih kecil daripada data ke-(j+N/2).Pada proses berikutnya, digunakan jarak (N/2)/2 atau
N/4. Data pertama dibandingkan dengan data dengan jarak N/4. Apabila data pertama
lebih besar dari data ke N/4 tersebut maka kedua data tersebut ditukar. Kemudian data
kedua dibandingkan dengan jarak yang sama yaitu N/4. Demikianlah seterusnya hingga
seluruh data dibandingkan sehingga semua data ke-j lebih kecil daripada data ke-(j+N/4).
Pada proses berikutnya, digunakan jarak (N/4)/2 atau N/8. Demikian seterusnya sampai
jarak yang digunakan adalah 1.
5. MERGE SORT

Merge sort adalah algoritma yang berdasarkan strategi divide-and-conquer.

Algoritma ini terdiri dari dua bagian utama, yaitu bagian pembagian list menjadi sublist-
sublist yang lebih kecil dan bagian sort (pengurutan) dan merge (penggabungan) pada
sublist-sublist tersebut.

 Divide: membagi masalah menjadi beberapa submasalah yang memiliki kemiripa n

dengan masalah semula namun berukuran lebih kecil (idealnya berukuran hampir
sama),

 Conquer: memecahkan (menyelesaikan) masing- masing submasalah (secara

rekursif), dan

 Combine: mengabungkan solusi masing-masing submasalah sehingga membentuk

solusi masalah semula.

6. QUICK SORT

Quick sort adalah metode pengurutan data yang dikemukakan pertama kali oleh C.
A. R. Hoare pada tahun 1962. Metode ini menggunakan strategi “pecah-pecah” dengan
mekanisme seperti berikut: Larik L[p..r] (dengan indeks terkecil adalah p dan indeks
terbesar yaitu r) disusun ulang (dipartisi) menjadi dua buah larik A[p..q] dan A[q+1..r]
sehingga setiap elemen dalam A[q+1..r]. Selanjutnya kedua larik tersebut diurutkan
secara rekursif. Dengan sendirinya kombinasi kedua larik tersebut membentuk larik
dengan data yang telah urut.
 BAB II
IMPLEMENTASI

Berikut ini beberapa implementasi sorting dengan bahasa pemrograman Java:

1. BUBBLE SORT
public void bubbleSort(int n) {
int[] arr = generateRandom(n);
boolean swapped = true;
int j = 0;
int tmp;
while (swapped) {
swapped = false;
j++;
for (int i = 0; i < arr.length - j; i++) {
if (arr[i] > arr[i + 1]) {
tmp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = tmp;
swapped = true;
}
}
}
for (int x = 0; x < n; x++) {
System.out.print(arr[x] + " ");
}
}
2. SELECTION SORT
public void selectionSort(int n) {
int i, j, minIndex, tmp;
int[] arr = generateRandom(n);
for (i = 0; i < n - 1; i++) {
minIndex = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
tmp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = tmp;
}
}
for (int x = 0; x < n; x++) {
 System.out.print(arr[x] + " ");
}
}
3. INSERTION SORT
public void insertionSort(int n) {
int i, j, newValue;
int[] arr = generateRandom(n);
for (i = 1; i < arr.length; i++) {
newValue = arr[i];
j = i;
while (j > 0 && arr[j - 1] > newValue) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = newValue;
}
for (int x = 0; x < n; x++) {
System.out.print(arr[x] + " ");
}
}
4. SHELL SORT
public void shellSort(int n) {
int[] arr = generateRandom(n);
int increment = arr.length / 2;
while (increment > 0) {
for (int i = increment; i < arr.length; i++) {
int j = i;
int temp = arr[i];
while (j >= increment && arr[j - increment]
> temp) {
arr[j] = arr[j - increment];
j = j - increment;
}
arr[j] = temp;
}
if (increment == 2) {
increment = 1;
} else {
increment *= (5.0 / 11);
}
}
for (int x = 0; x < n; x++) {
System.out.print(arr[x] + " ");
}
 }
5. MERGE SORT
public void mergeSort(int n) {
int arr[] = generateRandom(n);
arr = merge(arr);
for (int x = 0; x < n; x++) {
System.out.print(arr[x] + " ");
}
}

private int[] merge(int array[]) {

if (array.length > 1) {
int elementsInA1 = array.length / 2;
int elementsInA2 = elementsInA1;
if ((array.length % 2) == 1) {
elementsInA2 += 1;
}
int arr1[] = new int[elementsInA1];
int arr2[] = new int[elementsInA2];
for (int i = 0; i < elementsInA1; i++) {
arr1[i] = array[i];
}
for (int i = elementsInA1; i < elementsInA1 +
elementsInA2; i++) {
arr2[i - elementsInA1] = array[i];
}
arr1 = merge(arr1);
arr2 = merge(arr2);
int i = 0, j = 0, k = 0;
while (arr1.length != j && arr2.length != k) {
if (arr1[j] < arr2[k]) {
array[i] = arr1[j];
i++;
j++;
} else {
array[i] = arr2[k];
i++;
k++;
}
}
while (arr1.length != j) {
array[i] = arr1[j];
i++;
j++;
 }
while (arr2.length != k) {
array[i] = arr2[k];
i++;
k++;
}
}
return array;

}
}
6. QUICK SORT
public void quickSort(int n) {
int[] arr = generateRandom(n);
arr = quick(arr, 0, arr.length - 1);
for (int x = 0; x < n; x++) {
System.out.print(arr[x] + " ");
}
}

private int partition(int arr[], int left, int right) {

int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];

while (i <= j) {
while (arr[i] < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
}

return i;
}
private int[] quick(int arr[], int left, int right) {
int index = partition(arr, left, right);
if (left < index - 1) {
quick(arr, left, index - 1);
}
if (index < right) {
quick(arr, index, right);
}
return arr;
}
 BAB III
HASIL DAN PEMBAHASAN

Pada kali ini akan digunakan 6 algoritma sorting untuk mengurutkan data secara random.
Adapun macam-macam algoritma tersebut yaitu: bubble sort, selection sort, insertion sort,
shell sort, merge sort, quick sort. Dengan menguji masing-masing algoritma dengan variasi
nilai N =1000, 5000, 10000, 25000, 50000.

Spesifikasi komputer dan software yang digunakan adalah sebagai berikut:

 Sistem operasi: Windows 7 Home Basic 64-bit

 Prosesor: Intel(R) Celeron(R) CPU 1007U @ 1.50 GHz

 Memori: 4 GB

 Java: JavaT M Standard Edition Version 7 Update 51 (build 1.7.0_51-b13)

Berikut ini tabel hasil dari running time (ms) masing- masing algoritma sorting:

Sorting\N 1000 5000 10000 25000 50000

Bubble Sort 42 310 1112 5136 17563

Selection Sort 25 276 783 2855 8934

Insertion Sort 25 235 757 1835 5627

Shell Sort 25 276 532 1536 3046

Merge Sort 42 234 624 1424 2946

Quick Sort 25 154 457 1325 3044

Pada pengujian kali ini, algoritma sorting yang tercepat di antara 6 algoritma adalah
quick sort. Sedangkan algoritma sorting yang terlambat adalah bubble sort. Pada algoritma
bubble sort, ketika data N yang dimasukkan kecil, selisih running time dengan algoritma
sorting lainnya masih kecil/sedikit. Tetapi ketika data N yang dimasukkan semakin besar,
selisih runing time-nya menjadi semakin besar.

Berdasarkan hasil running time di atas, setiap algoritma sorting memiliki nilai worst
case dan best case yang berbeda-beda. Misalnya:

 Bubble sort memiliki nilai:

Worst case: O(N 2 )

Best case: O(N)

 Selection sort memiliki nilai :

Worst case: O(N 2 )

 Best case: O(N 2 )

 Insertion sort memiliki nilai :

Worst case: O(N 2 )

Best case: O(N)

 Shell sort memiliki nilai :

Worst case: O(N log2 N)

Best case: O(N)

 Merge sort memiliki nilai :

Worst case: O(N log N)

Best case: O(N log N)

 Quick sort memiliki nilai :

Worst case: O(N 2 )

Best case: O(N log N).

Penjelasan tentang kecepatan beberapa algoritma sorting dengan notasi Big O:

 Insertion sort

Kompleksitas untuk kasus terbaiknya adalah O(N). Pada kasus terbaik ini, elemen-
elemen pada array sudah terurut. Elemen di kiri lebih kecil daripada elemen di kanan.
Keterurutan pada elemen tersebut adalah menaik (ascending).

Kompleksitas untuk kasus terburuk adalah O(N 2 ). Pada kasus terburuk ini
keterurutan awal elemen-elemen pada array adalah menurun (descending).

Kompleksitas untuk kasus rata-rata adalah O(N 2 ). Hal ini terjadi jika array terurut
secara acak.

Insertion sort lebih simpel dan lebih baik digunakan untuk jumlah data yang sangat
kecil. Untuk jumlah data yang besar, insertion sort tidak cocok untuk diterapkan karena
kompleksitas waktu dari algoritma tersebut adalah O(N 2 ).

 Merge sort

Merge sort merupakan algoritma pengurutan yang bagus. Algoritma ini

mengaplikasikan pembagian elemen array menjadi 2 buah sub-array. Lalu,
menggabungkan data yang ada pada kedua buah sub-array tersebut. Kompleksitas waktu
untuk semua kasus dari algoritma merge sort adalah O(N log N).

 Quick sort

Kompleksitas untuk kasus terbaik dan kasus rata-rata adalah O(N log N).
 Kompleksitas untuk kasus terburuk adalah O(N 2 ).

Pemilihan pivot sangat penting karena bergantung pada pivot kita mendapatkan
kompleksitas waktu kasus terbaik atau terburuk. Jika pivot yang dipilih merupakan
elemen pertama atau terakhir dari array maka kompleksitas waktu yang didapat adalah
O(N 2 ).
 BAB IV
KESIMPULAN

Berdasarkan analisa dari masing-masing algoritma sorting dapat disimpulkan bahwa:

 Algoritma “quick sort” adalah algoritma paling efektif di antara 6 algoritma sorting yang
diujikan.
 Pada kondisi input N = 1000 dan 5000, semua algoritma sorting masih terasa efektif,
tetapi ketika input N-nya semakin besar, algoritma “bubble sort” menjadi kurang efektif
bahkan bisa menjadi tidak efektif.
 Kondisi spesifikasi dari hardware dan software komputer juga mempengaruhi running
time algoritma yang dijalankan.