BUBBLE SORT

A.

Pengertian Bubble Sort

Bubble Sort adalah salah satu algoritma untuk sorting data, atau kata lainnya
mengurutkan data dari yang terbesar ke yang terkecil atau sebaliknya (Ascending atau
Descending).
Bubble sort (metode gelembung) adalah metode/algoritma pengurutan dengan
dengan cara melakukan penukaran data dengan tepat disebelahnya secara terus
menerus sampai bisa dipastikan dalam satu iterasi tertentu tidak ada lagi perubahan.
Jika tidak ada perubahan berarti data sudah terurut. Disebut pengurutan gelembung
karena masing-masing kunci akan dengan lambat menggelembung ke posisinya yang
tepat.
Metode pengurutan gelembung (Bubble Sort) diinspirasikan oleh gelembung
sabun yang berada dipermukaan air. Karena berat jenis gelembung sabun lebih ringan
daripada berat jenis air, maka gelembung sabun selalu terapung ke atas permukaan.
Prinsip di atas dipakai pada pengurutan gelembung.
Algoritma bubble sort adalah salah satu algoritma pengurutan yang paling
simple, baik dalam hal pengertian maupun penerapannya. Ide dari algoritma ini adalah
mengulang proses pembandingan antara tiap-tiap elemen array dan menukarnya
apabila urutannya salah. Pembandingan elemen-elemen ini akan terus diulang hingga
tidak perlu dilakukan penukaran lagi. Algoritma ini termasuk dalam golongan algoritma
comparison sort, karena menggunakan perbandingan dalam operasi antar elemennya.
Berikut ini adalah gambaran dari algoritma bubble sort. Misalkan kita mempunyai
sebuah array dengan. Elemen-elemen 4 2 5 3 9. Proses yang akan terjadi apabila
digunakan algoritma bubblesort adalah sebagai berikut.
Pass pertama
(4 2 5 3 9) menjadi (2 4 5 3 9)
(2 4 5 3 9) menjadi (2 4 5 3 9)
(2 4 5 3 9) menjadi (2 4 3 5 9)
(2 4 3 5 9) menjadi (2 4 3 5 9)
Pass kedua
(2 4 3 5 9) menjadi (2 4 3 5 9)
(2 4 3 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
Pass ketiga
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
(2 3 4 5 9) menjadi (2 3 4 5 9)
Dapat dilihat pada proses di atas, sebenarnya pada pass kedua, langkah
kedua, array telah terurut. Namun algoritma tetap dilanjutkan hingga pass kedua
berakhir. Pass ketiga dilakukan karena definisi terurut dalam algoritma bubblesort
adalah tidak ada satupun penukaran pada suatu pass, sehingga pass ketiga
dibutuhkan untuk memverifikasi keurutan array tersebut.

B.

Algoritma Bubble Sort

1. Membandingkan data ke-i dengan data ke-(i+1) (tepat bersebelahan). Jika tidak
sesuai maka tukar (data ke-i = data ke-(i+1) dan data ke-(i+1) = data ke-i). Apa
maksudnya tidak sesuai? Jika kita menginginkan algoritme menghasilkan data
dengan urutan ascending (A-Z) kondisi tidak sesuai adalah data ke-i > data kei+1, dan sebaliknya untuk urutan descending (A-Z).
2. Membandingkan data ke-(i+1) dengan data ke-(i+2). Kita melakukan
pembandingan ini sampai data terakhir. Contoh: 1 dgn 2; 2 dgn 3; 3 dgn 4; 4
dgn 5 ; n-1 dgn n.
3. Selesai satu iterasi, adalah jika kita sudah selesai membandingkan antara (n-1)
dgn n. Setelah selesai satu iterasi kita lanjutkan lagi iterasi berikutnya sesuai
dengan aturan ke-1. mulai dari data ke-1 dgn data ke-2, dst.
4. Proses akan berhenti jika tidak ada pertukaran dalam satu iterasi.
Berikut langkah-langkah pengurutan dalam metode bubble sort:

C.

Kompleksitas Algoritma Bubble Sort

Kompleksitas Algoritma Bubble Sort dapat dilihat dari beberapa jenis kasus,
yaitu worst-case, average-case, dan best-case.
Kondisi Best-Case
Dalam kasus ini, data yang akan disorting telah terurut sebelumnya,
sehingga proses perbandingan hanya dilakukan sebanyak (n-1) kali, dengan

satu kali pass.Proses perbandingan dilakukan hanya untuk memverifikasi

keurutan data. Contoh Best-Case dapatdilihat pada pengurutan data 1 2 3 4 di
bawah ini.
Pass Pertama
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
Dari proses di atas, dapat dilihat bahwa tidak terjadi penukaran posisi
satu kalipun, sehingga tidak dilakukan pass selanjutnya. Perbandingan elemen
dilakukan sebanyak tiga kali. Proses perbandingan pada kondisi ini hanya
dilakukan sebanyak (n-1) kali. Persamaan Big-O yang diperoleh dari proses ini
adalah O(n). Dengan kata lain, pada kondisi Best-Case algoritma Bubble Sort
termasuk pada algoritma lanjar.

Kondisi Worst-Case
Dalam kasus ini, data terkecil berada pada ujung array. Contoh WorstCase dapat dilihat pada pengurutan data 4 3 2 1 di bawah ini.
Pass Pertama
(4 3 2 1) menjadi (3 4 2 1)
(3 4 2 1) menjadi (3 2 4 1)
(3 2 4 1) menjadi (3 2 1 4)
Pass Kedua
(3 2 1 4) menjadi (2 3 1 4)
(2 3 1 4) menjadi (2 1 3 4)

Pass Ketiga
(2 1 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
Pass Keempat
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)
(1 2 3 4) menjadi (1 2 3 4)

Dari langkah pengurutan di atas, terlihat bahwa setiap kali melakukan

satu pass, data terkecil akan bergeser ke arah awal sebanyak satu step.
Dengan kata lain, untuk menggeser data terkecil dari urutan keempat
menuju urutan pertama, dibutuhkan pass sebanyak tiga kali, ditambah satu kali
pass untuk memverifikasi. Sehingga jumlah proses pada kondisi best case
dapat dirumuskan sebagai berikut. Jumlah proses = n2+n (3)
Dalam persamaan (3) di atas, n adalah jumlah elemen yang akan
diurutkan. Sehingga notasi Big-O yang didapat adalah O(n2). Dengan kata lain,
pada kondisi worst-case, algoritma Bubble Sort termasuk dalam kategori
algoritma kuadratik.

Kondisi Average-Case
Pada kondisi average-case, jumlah pass ditentukan dari elemen mana
yang mengalami penggeseran ke kiri paling banyak. Hal ini dapat ditunjukkan
oleh proses pengurutan suatu array, misalkan saja (1 8 6 2). Dari (1 8 6 2),
dapat dilihat bahwa yang akan mengalami proses penggeseranpaling banyak
adalah elemen 2, yaitu sebanyak dua kali.

Pass Pertama
(1 8 6 2) menjadi (1 8 6 2)
(1 8 6 2) menjadi (1 6 8 2)
(1 6 8 2) menjadi (1 6 2 8)
Pass Kedua
(1 6 2 8) menjadi (1 6 2 8)
(1 6 2 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)
Pass Ketiga
(1 2 6 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)
(1 2 6 8) menjadi (1 2 6 8)
Dari proses pengurutan di atas, dapat dilihat bahwa untuk mengurutkan
diperlukan dua buah passing,ditambah satu buah passing untuk memverifikasi.
Dengan kata lain, jumlah proses perbandingan dapat dihitung sebagai
berikut. Jumlah proses = x2+x (4) Dalam persamaan (4) di atas, x adalah
jumlahpenggeseran terbanyak. Dalam hal ini, x tidak pernah lebih besar dari n,
sehingga x dapat dirumuskan sebagai
Dari persamaan (4) dan (5) di atas, dapat disimpulkan bahwa notasi bigO nya adalah O(n2). Dengan kata lain, pada kondisi average case algoritma
Bubble Sort termasuk dalam algoritma kuadratik.
D. Implementasi dalam Pseudo-Code
Setiap algoritma akan memiliki implementasi yang berbeda, tergantung dari
bahasa program yang dipakai. Oleh karena itu berikut ini adalah pseudo-code dari
algoritma bubblesort, untuk memudahkan implementasi bubblesort pada bahasa
apapun.
procedure bubbleSort( A : list of
sortable items ) defined as:
do
swapped := false
for each i in 0 to length(A) - 2
inclusive do:
if A[i] > A[i+1] then
swap( A[i], A[i+1] )
swapped := true
end if
end for
while swapped
end procedure
E. Kelebihan dan Kelemahan Bubble Sort
Kelebihan :
a. Metode Buble Sort merupakan metode yang paling simple
b. Metode Buble Sort mudah dipahami algoritmanya

Kelemahan:
Meskipun simpel metode Bubble sort
merupakan metode
pengurutan yang paling tidak efisien. Kelemahan buble sort adalah pada saat
mengurutkan data yang sangat besar akan mengalami kelambatan luar biasa,
atau dengan kata lain kinerja memburuk cukup signifikan ketika data yang
diolah jika data cukup banyak. Kelemahan lain adalah jumlah pengulangan
akan tetap sama jumlahnya walaupun data sesungguhnya sudah cukup terurut.
Hal ini disebabkan setiap data dibandingkan dengan setiap data yang lain untuk
menentukan posisinya.

Heap Sort

A. Penjelasan Singkat
Heap Sort adalah sebuah algoritma pengurutan yang paling lambat dari
algoritma yang memiliki kompleksitas O(n log n). Tetapi tidak seperti algoritma
Merge Sort dan Quick Sort, algoritma Heap Sort tidak memerlukan rekursif
yang besar atau menggunakan banyak tabel (array) . Oleh karena itu, Heap
Sort adalah pilihan yang baik untuk sebuah kumpulan data yang besar.
Algoritma ini dimulai dengan membangun sebuah array heap dengan
membangun tumpukan dari kumpulan data, lalu memindahkan data terbesar ke
bagian belakang dari sebuah tabel hasil. Setelah itu, array heap dibangun
kembali, kemudian mengambil elemen terbesar untuk diletakkan di sebelah
item yang telah dipindahkan tadi. Hal ini diulang sampai array heap habis.
Jadi secara umum, algoritma ini memerlukan dua buah tabel; satu tabel
untuk menyimpan heap, dan satu tabel lainnya untuk menyimpan hasil.
Walaupun lebih lambat dari Merge Sort atau Quick Sort, algoritma ini cocok
untuk digunakan pada data yang berukuran besar.
B. Algoritma Heap Sort
1. Pseudo-code
function heapSort(a, count)
{
var int start := count 2 - 1, end := count 1
while start 0
sift(a, start, count) start := start 1
while end > 0 swap(a[end], a[0]) sift(a, 0, end) end := end 1
}
function sift(a, start, count) { var int root := start, child while root * 2 + 1 <
count {
child := root * 2 + 1
if child < count - 1 and a[child] < a[child + 1]
child := child + 1 if a[root] < a[child]
swap(a[root], a[child]) root := child
else return
}
}
Keterangan :
swap : prosedur yang telah didefiniskan, untuk menukar isi dari argumen 1
dengan argumen 2.
2. Contoh implementasi
void heapSort(int numbers[], int array_size)
{
int i, temp;
for (i = (array_size / 2)-1; i >= 0; i--) siftDown(numbers, i, array_size);
for (i = array_size-1; i >= 1; i--)

{
temp = numbers[0]; numbers[0] = numbers[i]; numbers[i] =
temp; siftDown(numbers, 0, i-1);
}
}
void siftDown(int numbers[], int root, int bottom)
{
int done, maxChild, temp;
done = 0;
while ((root*2 <= bottom) && (!done))
{
if (root*2 == bottom) maxChild = root * 2;
else if (numbers[root * 2] > numbers[root * 2 + 1])
maxChild = root * 2; else
maxChild = root * 2 + 1;
if (numbers[root] < numbers[maxChild])
{
temp = numbers[root]; numbers[root] = numbers[maxChild];
numbers[maxChild] = temp;
root = maxChild;
}
else
done = 1;
}
}
3. Contoh kasus
1. Kasus terbaik (Best case)
Jika masukan yang diberikan dalam Heap Sort adalah berurutan
mengecil, maka akan diperoleh kasus terbaik untuk algoritma ini.
Karena dalam pembuatan pohon heap-nya hanya memerlukan sekali
pass saja, dan tidak dilakukan pertukaran elemen. Pertukaran hanya
dilakukan pada saat sudah tercapai pohon heap yang akarnya
berelemen terbesar, untuk menaruhnya pada tabel hasil.
Berikut adalah contoh gambar algoritma Heap Sort dengan
masukan : 3 2 1

2. Kasus terburuk (Worst case)

Sedangkan kasus terburuk terdapat pada masukan yang telah
berurut membesar. Hal ini diakibatkan karena pertukaran elemen yang
terjadi merupakan yang terbanyak dari kasus lainnya, dimana elemen
terbesar yang seharusnya berada di akar, terdapat di anak pohon yang
paling dalam.
Berikut adalah contoh gambar dari algoritma Heap Sort dengan
masukan : 1 2 3

3.

Kasus acak (Random case)

Kasus acak mempunyai urutan masukan yang tidak terdapat
pada dua kasus di atas, yaitu tidak diketahui di mana letak elemen
terbesar yang akan menjadi elemen akar.
Berikut adalah contoh algoritma Heap Sort dengan masukan : 2
13

4. Kesimpulan
Meskipun lebih lambat dari algoritma pengurutan data yang lain,
algoritma heap sort memiliki kelebihan ketika menangani data dalam

skala yang besar/massive. Karena algoritma ini memiliki kelebihan tidak

menggunakan banyak tabel, tetapi hanya satu tabel yang dipakai untuk
menyimpan hasil dari pengurutan tersebut.

QUICK SORT

A. Pengenalan
Algoritma quick sort diperkenalkan pertama kali oleh C.A.R. Hoare pada
tahun 1960, dan dimuat sebagai artikel di Computer Journal 5 pada April
1962. Quick sort adalah algoritma sorting yang berdasarkan pembandingan
dengan metoda divide-and-conqueror. Disebut Quick Sort, karena Algoritma
quick sort mengurutkan dengan sangat cepat. Quick sort disebut juga dengan
partition exchange sort, karena konsepnya membuat partisi-partisi, dan sort
dilakukan per partisi.
Teknik mempartisi tabel:
(i) pilih x {a1, a2, , an} sebagai elemen pivot.
(ii) pindai (scan) tabel dari kiri sampai ditemukan elemen ap x.
(iii) pindai tabel dari kanan sampai ditemukan elemen aq x
(iv) pertukarkan ap <-> aq
(v) ulangi (ii) dari posisi p + 1, dan (iii) dari posisi q 1, sampai kedua
pemindaian bertemu di tengah tabel.
Algoritma quick sort mengurutkan dengan sangat cepat, namun
algoritma ini sangat komplex dan diproses secara rekursif. Sangat
memungkinkan untuk menulis algoritma yang lebih cepat untuk beberapa kasus
khusus, namun untuk kasus umum, sampai saat ini tidak ada yang lebih cepat
dibandingkan algoritma quick sort.
Walaupun begitu algoritma quick sort tidak selalu merupakan pilihan
yang terbaik. Seperti yang telah disebutkan sebelumnya, algoritma ini dilakukan
secara rekursif yang berarti jika dilakukan untuk tabel yang berukuran sangat
besar, walaupun cepat, dapat menghabiskan memori yang besar pula. Selain
itu, algoritma ini adalah algoritma yang terlalu komplex untuk mengurutkan
tabel yang berukuran kecil (hanya puluhan elemen misalnya). Selain itu
algoritma quick sort mempunyai tingkat efisiensi yang buruk ketika dioperasikan
pada tabel yang hampir terurut atau pada tabel yang terurut menurun.
B. Algoritma Quick Sort
Dalam algoritma quick sort pemilihan pivot adalah hal yang menentukan
apakah algoritma quick sort tersebut akan memberikan performa terbaik atau
terburuk. Berikut beberapa cara pemilihan pivot :
1. Pivot adalah elemen pertama, elemen terakhir, atau elemen tengah
tabel. Cara ini hanya bagus jika elemen tabel tersusun secara acak,
tetapi tidak bagus jika elemen tabel semula sudah terurut. Misalnya,
jika elemen tabel semula menurun, maka semua elemen tabel akan
terkumpul di upatabel kanan.
2. Pivot dipilih secara acak dari salah satu elemen tabel. Cara ini baik,
tetapi mahal, sebab memerlukan biaya (cost) untuk pembangkitan
prosedur acak. Lagi pula, itu tidak mengurangi kompleksitas waktu
algoritma.
3. Pivot adalah elemen median tabel. Cara ini paling bagus, karena
hasil partisi menghasilkan dua bagian tabel yang berukuran
seimbang (masing masing n/2 elemen). Cara ini memberikan
kompleksitas waktu yang minimum. Masalahnya, mencari median
dari elemen tabel yang belum terurut adalah persoalan tersendiri.

C. Penjelasan Contoh Quick Sort

Saya akan menjelaskan algoritmanya menggunakan gambar. Pertama
perhatikan bahwa kita bisa memecah list menjadi dua bagian, tidak peduli
urutan di bagian kiri dan kanan. Jadi jika kita memiliki list:

Maka list tersebut bisa dipecah menjadi:

atau seperti ini:

Tergantung algoritma yang kita gunakan dalam memecah list. Saya contohkan dengan
algoritma yang saya pilih ini. Saya memiliki list berikut 6, 4, 8, 5, 3, 1, 7, 2:

Saya pilih 5 sebagai pivot (sembarang elemen boleh menjadi pivot, saya pilih yang
kira-kira di tengah). Tukarkan pivot ini dengan elemen terakhir.

Hasilnya seperti ini: 6*, 4, 8, 2, 3, 1, 7, 5 (pivot). Pada elemen pertama saya beri tanda
bintang (*), akan saya jelaskan nanti gunanya.

Sekarang kita akan mulai memproses list dari elemen pertama sampai elemen
sebelum pivot. Setiap kali menemukan elemen yang kurang dari pivot, saya pindahkan
(kita tukar) dengan elemen yang diberi tanda bintang. Lalu bintang dipindahkan satu
elemen ke kanan. Elemen pertama (6) lebih besar dari pivot (5), jadi kita cek elemen
berikutnya yaitu 4. Karena 4 kurang dari pivot, kita tukarkan 4 dengan elemen yang
bertanda *. Hasilnya:

Hasilnya: 4, *6, 8, 2, 3, 1, 7, 5 (pivot). Ingat bahwa setelah menukar, tanda * dipindah

satu elemen ke kanan.

Berikutnya kita lihat bahwa 8 lebih dari pivot, jadi kita biarkan. Elemen 2 kurang dari
pivot, sehingga perlu ditukar dengan *.

Dan hasilnya adalah: 4, 2, *8, 6, 3, 1, 7, 5 (pivot).

Elemen 3 juga kurang dari pivot, jadi kita perlu menukarnya.

Hasilnya adalah: 4, 2, 3, *6, 8, 1, 7, 5 (pivot).

Dan yang terakhir yang kurang dari pivot adalah 1.

Hasilnya adalah: 4, 2, 3, 1, *8, 6, 7, 5 (pivot).

Dan langkah terakhir adalah menukar posisi * dengan pivot:

Hasil akhirnya adalah list yang terbagi dua (semua elemen di kiri 5 lebih kecil dari 5
dan semua elemen di kanan 5 lebih besar dari 5): 4, 2, 3, 1, 5, 6, 7, 8:

Atau jika digambarkan, yang saya lakukan adalah seperti ini: memecah list awal,
menjadi dua list, yang satu berisi elemen-elemen yang lebih kecil dari 5, dan list yang
berisi elemen-elemen yang lebih besar atau sama dengan 5.

Skrip Program
void _quicksort(int *elements, int left, int right)
{
int pivotposition;
/* jika left >= right, berarti list kosong */
if (left < right) {
pivotposition = partition(elements, left, right);
/*urutkan elemen-elemen di kiri pivot*/
_quicksort(elements, left, pivotposition - 1);
/*urutkan elemen-elemen di kanan pivot*/
_quicksort(elements, pivotposition + 1, right);
}}

Sekilas tentang Bubble Sort, Quick Sort, Heap Sort

Sorting berarti proses pengurutan. 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.
Beberapa Metode Sorting antara lain Bubble Sort , Quick Sort, Heap 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 kita
pelajari, metode ini merupakan metode yang paling tidak efisien.
Metode Quick sering disebut juga metode partisi (partition exchange sort).
Untuk mempertinggi efektifitas dari metode ini, digunakan teknik menukarkan dua
elemen dengan jarak yang cukup besar. Dasar strateginya adalah memecah dan
menguasai. Quick sort dimulai dengan menscan daftar yang disortir untuk nilai
median. Nilai ini, yang disebut tumpuan (pivot), kemudian dipindahkan ke satu sisi
pada daftar dan butir-butir yang nilainya lebih besar dari tumpuan di pindahkan ke sisi
lain.
Metode heap sort adalah metode dari pengembangan tree. Metode Heap sort
memiliki kecepatan O(N log N). Heap sort melakukan suatu pengurutan menggunakan
suatu struktur data yang di sebut heap. Heap memiliki kompleksitas yang besar dalam
pembuatan kodenya, tetapi heap sort mampu mengurutkan data-data yang sangat
banyak dengan waktu yang cepat.

DAFTAR PUSTAKA

http://jagocoding.com/tutorial/188/Tutorial_Bubble_Sort
www.informatika.unsyiah.ac.id/tfa/ds/bubblesort.pdf
http://buublesort.blogspot.com/
http://frediannotes.blogspot.com/2013/02/pengurutan-bilangan-denganmetode_7646.html
http://kris-tips-trick.blogspot.com/2011/05/metoda-pengurutan-bubble-sortdengan.html
www.informatika.stei.itb.ac.id/.../MakalahStmik2006-60. pdf
http://emirzamahendra.blogspot.com/2014/10/sekilas-tentang-metode-metodesorting.html