ANALISIS ALGORITMA PADA MASALAH SORTING

Oleh Dea Rokhmatun Iradewa (0700940)

Program Ilmu Komputer UPI

Dalam ilmu komputer, yang dimaksud dengan algoritma pengurutan pada dasarnya
adalah :
• algoritma yang meletakkan elemen-elemen suatu kumpulan data dalam urutan
tertentu.
• Proses pengurutan data yg sebelumnya disusun secara acak sehingga
menjadi tersusun secara teratur menurut suatu aturan tertentu. Yang pada
kenyataannya ‘urutan tertentu’ yang umum digunakan adalah terurut secara
numerikal ataupun secara leksikografi (urutan secara alfabetis).
• Ada 2 jenis pengurutan, yaitu Ascending (naik) & Descending (turun)

1. Buble Sort
Bubble sort atau yang disebut juga metode pengurutan apung adalah salah
satu metode pengurutan yang bersifat langsung dan termasuk jenis pengurutan
yang paling sederhana. Metode ini terinspirasi oleh gelembung sabun di air dimana
delembung sabun yang lebih ringan dari air akan selalu naik ke permukaan. Nama
bubble sort sendiri berasal dari sifat nilai terbesar yang selalu naik (ke akhir dari list)
seperti gelembung sabun (bubble).
Konsep dari bubble sort adalah sebagai berikut :
o Pengecekan dimulai dari elemen paling awal
o Elemen ke-1 dan ke-2 dari list dibandingkan
o Jika elemen pertama lebih besar dari elemen kedua, dilakukan pertukaran.
o Langkah 2 dan 3 dilakukan lagi terhadap elemen kedua dan ketiga,
seterusnya sampai elemen
 o terakhir.
o Bila sudah sampai di elemen terakhir dilakukan pengulangan lagi dari awal
sampai tidak ada terjadi
o lagi pertukaran elemen.
o Bila tidak ada pertukaran elemen lagi, maka elemen list terurut.

Salah satu kelebihan algoritma bubble sort, terjadi saat semua elemen
sudah terurut di mana hanya terjadi pengecekan pada setiap elemen, sehingga
penelusuran hanya dilakukan satu kali saja. Ini merupakan kasus terbaik yang
mungkin terjadi pada algoritma ini.
Kelebihan lain dari algoritma ini adalah dapat dieksekusi dan dijalankan
dengan cukup cepat. Keadaan terbaik terjadi bila data yang hendak disorting sudah
terurut, Berapapun jumlah elemen datanya, jika data ya sudah terurut, maka Bubble
Sort tersebut hanya melewatinya satu kali yaitu O(1500).
Namun jika keadaan datanya belum terurut sama sekali, makadengan
jumlah data 20 saja, pada perbandingan yang dilakukan = O(202) = O(4000) -> Lebih
besar dibanding 1500 data pada kondisi terurut
Oleh karena itu, metode pengurutan apung atau buble sort bukan
merupakan metode pengurutan yang efisien. Hal ini disebabkan oleh banyaknya
kemungkinan pertukaran yang terjadi pada proses pengapungan (baca: pengurutan)
data. Untuk jumlah data yang banyak, maka algoritma ini akan mebutuhkan waktu
yang lama. Namun kelebihan dari algoritma ini adalah kesederhanaan dan pola nya
yang mudah dipahami.
 Efisiensi buble sort

Berdasarkan tabel, tidak ada perbedaan performansi secara signifikan untuk

pengurutan terhadap 100 item atau kurang. Namun, bubble sort tidak
disarankan untuk pengurutan yang terus berulang, atau pengurutan yang
menangani lebih dari 200 item.
Pola Pengurutan Dengan Buble Sort :
o Data awal yang belum terurut :

o Penentuan bilangan yang akan menjadi acun (bilangan 26)

o Inisialisasi elemen kiri sebagai bilangan kedua dari kumpulan bilangan dan
elemen kiri sebagai bilangan terakhir dari kumpulan bilangan

o Geser elemen kiri kearah kanan sampai ditemukan nilai yang lebih besar dari
elemen tumpuan tersebut. Geser elemen kanan ke arah kiri sampai ditemukan
nilai dari elemen yang tidak lebih besar dari elemen tersebut.
 o Ulangi

o Tukar elemen tumpuan dengan elemen kiri

o Urutkan sub bagian yang terhalang oleh tumpuan

2. Insertion Sort
Insertion Sort adalah sebuah algoritma pengurutan sederhana, dengan
cara pengurutan perbandingan yang mengurutkan suatu array atau list dengan
membuat suatu entry.
Metode ini tidak begitu mangkus dalam mengolah data yang besar
(banyak) dibandingkan algoritma-algoritma yang lebih maju seperti Quicksort, tetapi
mempunyai banyak keuntungan, diantaranya :
1. Sederhana dalam penerapan
2. Mangkus dalam pengolahan data yang kecil
3. Mangkus dalam data yang sudah sebagian terurut
4. Lebih mangkus dibanding Bubble Sort maupun Selection Sort
5. Stabil
Algoritma insertion sort dalam bahasa C :

Void insertion_sort(apvector <int> &array) {

int i,j,key,array_length=array.length();
for(j=1;j<array_length;j++) {
key=array[j];
for(i=j;(i>=0)&&(array[i]<key);i--) {
aray[i+1]=array[i];
}
array[i+1]=key;
}
return;
}

Keadaan terbaik didapat ketika list sudah dalam keadaan terurut, maka
pengurutan ini hanya memakanwaktu O(n): dalam setiap iterasi, elemen pertama
list hanya dibandingkan dengan elemen terakhir dari list.
Salah satu kelebihan metode ini adalah Jika list sudah terurut atau
sebagian terurut maka Insertion Sort akan lebih cepat dibandingkan dengan
Quicksort.
Keadaan terburuk dari algoritma ini adalah jika list terurut terbalik
sehingga setiap eksekusi dari perintah harus memindai dan mengganti seluruh
bagian sebelum menyisipkan elemen berikutnya.
Insertion Sort membutuhkan waktu O(n2) pada data yang tidak terurut,
sehingga tidak cocok dalam pengurutan elemen dalam jumlah besar. Walaupun
demikian, loop dalam pada Inserion Sort sangat cepat, yang membuatnya salah satu
algoritma pengurutan tercepat pada jumlah elemen yang sedikit. Sama halnya
dengan buble sort, metode ini tidak mangkus (efektip) jika jumlah elemen data yang
akan diurutkan banyak
Contoh proses pengurutan bilangan 84,69,76,86,94,91 dengan
den algoritma
insertion sort
3. Selection Sort
Layaknya insertion sort, algoritma ini sangat simple dan mudah untuk
diimplementasikan. Ide utama dari algoritma selection sort adalah memilih elemen
dengan nilai paling rendah dan menukar elemen yang terpilih dengan elemen ke-i.
Nilai dari i dimulai dari 1 ke n, dimana n adalah jumlah total elemen dikurangi 1.
Contoh algoritma selection sort:

void selectionSort(Object array[], int startIdx, int endIdx) {

int min;
for (int i = startIdx; i < endIdx; i++) {
min = i;
for (int j = i + 1; j < endIdx; j++) {
if (((Comparable)array[min]).compareTo(array[j])>0) {
min = j;
}
}
swap(array[min], array[i]);
}
}

Untuk memilih elemen terkecil memerlukan pemindaian seluruh (n)

elemen yang membutuhkan n-1 kali perbandingan lalu memindahkannya ke posisi
pertama. Sedang untuk memilih elemen kedua terkecil memerlukan pemindaian
dari n-1 elemen dan begitu seterusnya sehingga (n-1) + (n-2) + ... + 2 + 1 = n(n-1)/2=
O(n 2) perbandingan. Tiap perbandingan memerlukan satu kali pertukaran untuk n-1
elemen. Karena itu perbandingan mendominasi waktu pemrosesan yaitu O(n2).
4. Merge Sort
Merge Sort adalah suatu algoritma pengurutan berbasis perbandingan.
Algiritma ini merupakan salah satu contoh algoritma pembagian. Algoritma ini
ditemukan oleh John von Neumann pada tahun 1945. Algoritma ini menggunakan
konsep rekursip. Beberapa konsep yang harus dipahami sbelum menelusuri
algoritma Merge sort:
o Divide
Memilah masalah menjadi sub masalah
o Conquer
Selesaikan sub masalah tersebut secara rekursif. Jika sub-masalah
tersebut cukup ringkas dan sederhana, pendekatan penyelesaian secara
langsung akan lebih efektif
o Kombinasi
Mengkombinasikan solusi dari sub-masalah, yang akan
membimbing menuju penyelesaian atas permasalahan utama

Berikut
menjelaskan langkah kerja dari Merge sort.
o Divide
Memilah elemen – elemen dari rangkaian data menjadi dua bagian.
o Conquer
Conquer setiap bagian dengan memanggil prosedur merge sort secara rekursif
o Kombinasi
Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkan
rangkaian data berurutan
Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi
bilamana bagian yang akan diurutkan menyisakan tepat satu elemen. Sisa
pengurutan satu elemen tersebut menandakan bahwa bagian tersebut telah
terurut sesuai rangkaian.
Berikut algoritma pengurutan dengan merge sort:
 void mergesort(int numbers[],int temp[],int array_size)
{
m_sort(numbers,temp,0,array_size-1);
}

void m_sort(int numbers[],int temp[],int left,int right)

{
int mid;
if(right > left)
{
mid=(right+left)/2;
m_sort(numbers,temp,left,mid);
m_sort(numbers,temp,mid+1,right);
merge(numbers,temp,left,mid+1,right);
}
}

void merge(int numbers[],int temp[],int left,int mid,int right)

{
int i,left_end,num_element,tmp_pos;
left_end=mid-1;
tmp_pos=left;
num_elements=right-left+1;
while((left<=left_end)&&(mid<=right))
{
if numbers[left]<=numbers[mid]
{
temp[tmp_pos]=numbers[left];
tmp_pos=tmp_pos+1;
left=left+1;
}
else
{
temp[tmp_pos]=numbers[mid];
tmp_pos=tmp_pos+1;
mid=mid+1;
}
}
while (left<=left_end)
{
temp[tmp_pos]=numbers[left];
left=left+1;
tmp_pos=tmp_pos+1;
}
 while (mid<=right)
{
temp[tmp_pos]=number[mid];
mid=mid+1;
tmp_pos=tmp_pos+1;
}
for(i=0;i<=num_elements;i++)
{
numbers[right]=temp[right];
right=right-1;
}
}

5. Quick sort
Algoritma Quick sort :

array [1..10] of integer x <- { 34,67,23,28,98)

procedure quicksort(input : integer l,integer r)
integer i
integer j
i <- l
j <- r
repeat
while x(i) < x(l) do
i <- i+1
{end while}
while x(j) > x(l) do
j <- j-1
{end while}
if i<j then
integer temp
temp <- x(i)
x(i) <- x(j)
x(j) <- temp
i <- i+1
j <- j-1
{end if}
 until (i>j)
if l<j then
quicksort(l,j)
{end if}
if i<r then
quicksort(i,r);
{end if}

Sesuai dengan namanya, metode ini terbilang cepat dalam mengurutkan

data, namun memang, cukup sumit dan sulit. Metode quicksort adalah metode
pengurutan yang menjadikan sebuah tabel data yang akan diurutkan menjadi dua
buah subbagian yang ditelusuri dari kiri dan dari kanan.

Contoh untuk proses pengurutan bilangan pada contoh pseudo-code di atas

dengan bilangan berikut 26,76,49,23,56,37 :

o Data awal yang belum terurut :

26,76,49,23,56,37
o Penentuan bilangan yang akan menjadi pivot (bilangan 26)
o Inisialisasi elemen kiri sebagai bilangan kedua dari kumpulan bilangan dan
elemen kiri sebagai bilangan terakhir dari kumpulan bilangan
26,76,49,23,56,37
o Geser elemen kiri kearah kanan sampai ditemukan nilai yang lebih besar dari
elemen pivot tersebut. Geser elemen kanan ke arah kiri sampai ditemukan
nilai dari elemen yang tidak lebih besar dari elemen tersebut
26,37,49,23,56,76
o Lanjutkan
26,37,49,23,56,76
26,37,23,49,56,76
o Tukar vipot dengan elemen kiri
 23,37,26,49,56,76
o Urutkan sub bagian yang terbagi pivot
23,37,26,49,56,76

Reff:
Munir, Rinaldi. (2007). Algoritma & Pemrograman dalam bahasa pascal dan C.Bandung:informatika

http://id.wikipedia.org