Kata Pengantar

Puji syukur kehadirat Allah SWT yang telah memberikan rahmat dan hidayah-Nya
sehingga saya dapat menyelesaikan tugas makalah yang berjudul BUBBLE
SORTING ini tepat pada waktunya. Adapun tujuan dari penulisan dari makalah ini
adalah untuk memenuhi tugas dosen pada mata kuliah Algoritma dan struktur data.
Saya mengucapkan terima kasih kepada ibu Munjiat Setiani Asih, ST, M.Kom.
selaku dosen Algoritma dan Struktur data yang telah memberikan tugas ini sehingga
dapat menambah pengetahuan dan wawasan sesuai dengan bidang studi yang saya
tekuni.
Saya juga mengucapkan terima kasih kepada semua pihak yang telah membagi
sebagian pengetahuannya sehingga saya dapat menyelesaikan makalah ini.Saya
menyadari, makalah yang saya tulis ini masih jauh dari kata sempurna. Oleh karena
itu, kritik dan saran yang membangun akan saya nantikan demi kesempurnaan
makalah ini.

Medan,29 Desember 2019

i
 Daftar Isi

Kata Pengantar ........................................................................................................................... i

Daftar Isi ................................................................................................................................... ii
BAB I ........................................................................................................................................ 1
PENDAHULUAN .................................................................................................................... 1
1.1. Latar Belakang ............................................................................................................... 1
1.2 Rumusan Masalah ........................................................................................................... 2
1.3 Tujuan ............................................................................................................................. 2
BAB II....................................................................................................................................... 3
PEMBAHASAN ....................................................................................................................... 3
2.1 Pengertian Algoritma Sorting ......................................................................................... 3
2.2 Pengertian Bubble Sorting ............................................................................................. 3
2.2.1 Ilustrasi dari Bubble Sort .......................................................................................... 5
2.2.2 Notasi Algoritmik dan Kompleksitas Waktu Bubble Sort ........................................ 7
2.3 Contoh Program Bubble Sort ........................................................................................ 13
BAB III ................................................................................................................................... 16
PENUTUP .............................................................................................................................. 16
3.1 Kesimpulan ................................................................................................................... 16

ii
iii
 BAB I

PENDAHULUAN

1.1. Latar Belakang

Dalam matematika dan komputasi, algoritma merupakan kumpulan perintah untuk

menyelesaikan suatu masalah. Perintah-perintah ini dapat diterjemahkan secara
bertahap dari awal hingga akhir. Masalah tersebut dapat berupa apa saja, dengan
syarat untuk setiap permasalahan memiliki kriteria kondisi awal yang harus dipenuhi
sebelum menjalankan sebuah algoritma. Algoritma akan selalu berakhir untuk semua
kondisi awal yang memenuhi criteria, hal ini berbeda dengan heuristik. Algoritma
juga memiliki pengulangan proses (iterasi), dan juga memiliki keputusan hingga
keputusan selesai.

Desain dan analisis algoritma merupakan suatu cabang khusus dalam ilmu computer
yang mempelajari karakteristik dan performa dari suatu algoritma dalam penyelesaian
masalah, terlepas dari implementasi algoritma tersebut. Dalam cabang disiplin ini,
algoritma dipelajari secara abstrak, terlepas dari system komputer atau bahasa
pemrograman yang dipergunakan. Algoritma yang berbeda dapat diterapkan untuk
suatu permasalahan dengan kriteria yang sama.

Kompleksitas dari suatu algoritma merupakan ukuran seberapa banyak komputasi

yang diterapkan algoritma tersebut untuk menyelesaikan permasalahannya. Secara
informal, algoritma yang dapat menyelesaikan permasalahan dalam waktu yang
relative singkat memiliki tingkat kompleksitas yang rendah, semetara algoritma yang
menyelesaikan permasalahan dalam waktu yang lebih lama memiliki tingkat

1
kompleksitas yang lebih tinggi pula.Dalam mata kuliah Algoritma dan Struktur data,
kita telah mempelajari tentang algoritma dan penerapannya dalam pemrograman

computer. Kesulitan yang dihadapi dalam permasalahan ini adalah susahnya kita
mengerti algoritma dan penyelesaian dari permasalahan yang dihadapi, serta sulitnya
membayangkan struktur data yang akan digunakan. Dalam memahami penyelesaian
suatu permasalahan, kita akan lebih mudah untuk mengingat dan memahaminya
apabila permasalahan itu dapat ditampilkan dalam bentuk visual dan gambar,
sehingga penyajian nya menjadi lebih menarik.Sedangkan shorting adalah proses
merangkai benda dalam urutan tertentu dan atau dalam himpunan yang berbeda.
Algoritma sorting banyak sekali mcam,salah satunya yaitu Bubble Sorting.

1.2 Rumusan Masalah

Dari latar belakang diatas adapun pemasalahan kami yaitu:
1. Apa pengertian Algoritma Sorting?
2. Apa pengertian Bubble Sort?
3. Bagaimana proses Bubble Sort?

1.3 Tujuan
Dari rumusan masalah diatas adapun tujuan kami yaitu:
1. Untuk mengetahui penngertian dari Algoritma Sorting
2. Untuk mengetahui pengertian dari Bubble Sorting
3. Untuk mengetahui bagaimana proses algoritma Bubble sorting

2
 BAB II

PEMBAHASAN

2.1 Pengertian Algoritma Sorting

Pengertian Algoritma Sorting adalah kumpulan langkah sistematis atau secara berutan
untuk memperoleh hasil yang diinginkan. Salah satu contoh dari algoritma untuk
langkah ini adalah Sorting (pengurutan). Sorting dapat didefinisikan sebagai
pengurutan sejumlah data berdasarkan nilai tertentu. Pengurutan dapat dilakukan dari
nilai terkecil ke nilai terbesar (ascending) atau sebaliknya.

Sorting dapat dibedakan menjadi dua yaitu Comparasion Sort (Bubble Sort, Selection
Sort, Insertion Sort, Merge Sort, Quick Sort) dan Non-Comparasion Sort (Radix Sort,
Counting Sort). Comparasion Sort / penggurutan dengan pembandingan adalah
algoritma yang dalam proses pengurutannya melakukan pembandingan antar data.
Non-Comparasion Sort / pengurutan tanpa pembandingan adalah algoritma
pengurutan dimana dalam prosesnya tidak melakukan perbandingan antar data.

2.2 Pengertian Bubble Sorting

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.

3
Diberi nama “Bubble” karena proses pengurutan secara berangsur-angsur
bergerak/berpindah ke posisinya yang tepat, seperti gelembung yang keluar dari
sebuah gelas bersoda. Gagasan dasar dari algoritma Bubble Sort adalah
membandingkan sepasang elemen yang berurutan di dalam larik dan mempertukarkan
keduanya jika perlu. Nama bubble sort ini berasal dari sifat elemen terbesar yang
selalu naik ke atas seperti bubble.
Ide dari bubble sort adalah sebagai berikut :
1. Algoritma dimulai dari elemen paling awal.
2. 2 buah elemen pertama dari list dibandingkan.
3. Jika elemen pertama lebih besar dari elemen kedua,dilakukan pertukaran.
4. Langkah 2 dan 3 dilakukan lagi terhadap elemen kedua dan ketiga, seterusnya
sampai ke ujung elemen
5. Bila sudah sampai ke ujung dilakukan lagi ke awal sampai tidak ada terjadi lagi
pertukaran elemen.
6. Bila tidak ada pertukaran elemen lagi, maka list elemen sudah terurut

Algoritma ini seolah-olah menggeser satu per satu elemen dari kanan ke kiri atau kiri
ke kanan, tergantung jenis pengurutannya, ascending atau descending.
1. Pengurutan Ascending : Jika elemen sekarang lebih besar dari elemen berikutnya
maka kedua elemen tersebut ditukar (Pengurutan dari kecil ke besar).
2. Pengurutan Descending : Jika elemen sekarang lebih kecil dari elemen
berikutnya, maka kedua elemen tersebut ditukar (Pengurutan dari besar ke kecil).

Ketika satu proses telah selesai, maka bubble sort akan mengulangi proses, demikian
seterusnya dari 0 sampai dengan iterasi sebanyak n-1. Kapan berhentinya? Bubble
sort berhenti jika seluruh array telah diperiksa dan tidak ada pertukaran lagi yang bisa
dilakukan, serta tercapai perurutan yang telah diinginkan.

4
2.2.1 Ilustrasi dari Bubble Sort

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 bubble sort adalah tidak ada
satupun penukaran pada suatu pass, sehingga pass ketiga dibutuhkan untuk
memverifikasi keurutan array tersebut.

***Kura-kura dan Kelinci pada Bubble Sort***

Dalam algoritma Bubble Sort ini, terdapat beberapa ciri khas yang cukup menonjol,
Ciri khas dari algoritma Bubble Sort ini adalah cepatnya elemen-elemen besar

5
menempati posisi yang tepat dan lambatnya elemen-elemen yang lebih kecil dalam
menempati posisi yang tepat. Hal ini dapat ditunjukkan pada contoh data “9 2 4 1”
yang akan diurutkan berikut ini menggunakan algoritma Bubble Sort.

Pass Pertama
(9 2 4 1) menjadi (2 9 4 1)
(2 9 4 1) menjadi (2 4 9 1)
(2 4 9 1) menjadi (2 4 1 9)
Pass Kedua
(2 4 1 9) menjadi (2 4 1 9)
(2 4 1 9) menjadi (2 1 4 9)
(2 1 4 9) menjadi (2 1 4 9)
Pass Ketiga
(2 1 4 9) menjadi (1 2 4 9)
(1 2 4 9) menjadi (1 2 4 9)
(1 2 4 9) menjadi (1 2 4 9)
Pass Keempat
(1 2 4 9) menjadi (1 2 4 9)
(1 2 4 9) menjadi (1 2 4 9)
(1 2 4 9) menjadi (1 2 4 9)

Dari proses pengurutan di atas, dapat dilihat bahwa elemen terbesar, “9”, langsung
menempati posisi akhir pada pass pertama. Akan tetapi elemen terkecil, “1”, baru
menempati posisi pertama pada pass keempat, yaitu pass yang terakhir. Oleh karena
itu, muncullah istilah “kura-kura” dan “kelinci” dalam algoritma Bubble Sort. Pada
contoh di atas, “1” berperan sebagai “kura-kura”, sedangkan “9” berperan sebagai
“kelinci”. Fenomena “kura-kura dan kelinci” ini sering kali mengakibatkan proses
pengurutan menjadi lama, terutama elemen “kura-kura”. Hal ini disebabkan oleh
“kura-kura” membutuhkan satu kali pass hanya untuk bergeser posisi ke sebelah kiri

6
2.2.2 Notasi Algoritmik dan Kompleksitas Waktu Bubble Sort

a. Notasi Algoritmik Bubble Sort

Pada dasarnya sorting adalah pengurutan. Ya, semua pasti juga tau apa itu
pengurutan, tapi apakah semua tau bagaimana pengurutan itu sendiri? Dari yang saya
pelajari, sorting adalah proses mengatur sekumpulan objek menurut aturan atau
susunan tertentu. Urutan objek tersebut dapat menaik atau disebut juga ascending
(dari data kecil ke data lebih besar) ataupun menurun/descending(dari data besar ke
data kecil).

Ada banyak macam metode sorting, namun kali ini saya akan menuliskan notasi
algoritma sorting dengan metode bubble sort dan insertion sort menggunakan array.

(Maaf jika adanya kekurangan dalam segi kerapian indentasi dikarenakan tidak bisa
diberi indent secara otomatis oleh karena saya copy-paste dari catatan yang saya tulis
sendiri di notepad++ sebelumnya. Yang sebenarnya text aslinnya semuanya di
notepad++ sudah dalam kondisi berindentasi/rapi)

/*
NAMA : NATHANAEL FREDERICKO W
NIM : A11.2018.10882
MAKUL : DASAR PRMROGRAMAN (TEORI)
TEMPAT : RUMAH
TANGGAL : 29-11-2018
PROGRAM : METODE SORTING
*/

// JUDUL
BUBBLE SORT

// KAMUS
arr <- array [n] of integer
a,b <- integer
n <- integer
temp <- integer

// DISKRIPSI
input (n)
a <- 0
while (a < n) do
{
input (arr[a])

7
a <- a + 1
}

a <- 0
while (a < n) do
{
b <- a + 1
while (b < n+1) do
{
if (arr[a] > arr[b]) then
{
temp <- arr[a]
arr[a] <- arr[b]
arr[b] <- temp
}
b <- b + 1
}
a <- a + 1
}

a <- 0
while (a < n) do
{
output (arr[a])
a <- a + 1

b.Kompleksitas Waktu 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
dapat dilihat pada pengurutan data “1 2 3 4” di bawah ini.

8
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).

Kondisi Worst-Case
Dalam kasus ini, data terkecil berada pada ujung array. Contoh Worst-Case 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)
(2 1 3 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)
(1 2 3 4) menjadi (1 2 3 4)
Pass Keempat
(1 2 3 4) menjadi (1 2 3 4)

9
(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

Dalam persamaan 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 penggeseran paling 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)

10
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

Dari persamaan di atas, dapat disimpulkan bahwa notasi big-O nya adalah O(n2).
Dengan kata lain, pada kondisi average case algoritma Bubble Sort termasuk dalam
algoritma kuadratik.

c. Kelebihan dan Kekurangan Algoritma Bubble Sort

Setiap algoritma memiliki kelebihan dan kekurangannya masing-masing, demikian

pula denganalgoritma Bubble Sort. Kelebihan dan kekurangan darialgoritma Bubble
Sort dapat dilihat dari karakteristik algoritma Bubble Sort itu sendiri. Berikut ini
adalah beberapa kelebihan dan kekurangan dari algoritma Bubble Sort.
Kelebihan Bubble Sort
Beberapa kelebihan dari algoritma Bubble Sort adalah sebagai berikut :
1. Algoritma yang simpel.
2. Mudah untuk diubah menjadi kode.
3. Definisi terurut terdapat dengan jelas dalam algoritma.
4. Cocok untuk pengurutan data dengan elemen kecil telah terurut.

11
Algoritma yang simpel. Hal ini dilihat dari proses pengurutan yang hanya
menggunakan rekurens dan perbandingan, tanpa penggunaan proses lain. Algoritma
pengurutan lain cenderung menggunakan proses lain, misalnya proses partisi pada
algoritma Quick Sort. Mudah untuk diubah menjadi kode. Hal ini diakibatkan oleh
simpelnya algoritma Bubble Sort, sehingga kecil kemungkinan terjadi kesalahan
sintax dalam pembuatan kode.

Definisi terurut terdapat dengan jelas dalam algoritma. Definisi terurut ini adalah
tidak adanya satu kalipun swap pada satu kali pass. Berbeda dengan algoritma lain
yang seringkali tidak memiliki definisi terurut yang jelas tertera pada algoritmanya,
misalnya Quick Sort yang hanya melakukan partisi hingga hanya ada dua buah nilai
yang bisa dibandingkan.

Cocok untuk pengurutan data dengan elemen kecil telah terurut. Algoritma Bubble
Sort memiliki kondisi best case dengan kompleksitas algoritma O(n).
Kekurangan Bubble Sort
Beberapa kekurangan dari algoritma Bubble Sort adalah sebagai berikut :
1. Tidak efektif dalam pengurutan data berskala besar.
2. Langkah pengurutan yang terlalu panjang.

Kekurangan terbesar dari Bubble Sort adalah kompleksitas algoritma yang terlalu
besar, baik dalam average case maupun worst case, yaitu O(n2), sehingga seringkali
disebut sebagai algoritma primitif, brute-force, maupun algoritma naïf. Untuk 1000
buah data misalnya, maka akan terjadi proses tidak lebih dari satu juta proses
perbandingan. Kompleksitas yang besar ini juga seringkali membuat algoritma
Bubble Sort sebagai “the general bad algorithm”. Bahkan, diantara algoritma
pengurutan lain yang memiliki kompleksitas algoritma O(n2), insertion sort
cenderung lebih efisien

12
2.3 Contoh Program Bubble Sort
Pada kesempatan kali ini kita akan membuat contoh program bubble sort pada
bahasa c++ yaitu mengurutka nilai terbesar ke nilai terkecil.

3.

4.
5.

keterangan:
- baris 5 -7 = adalah pendeklarasian variabel dan array yang akan digunakan
dalam program
- baris 10-13 = Proses inputan yang disimpan dalam array yang dilakukan
dalam perulangan
- baris 14-26 = Proses pengurutan antara elemen satu dengan yang lain dan
apabila elemen satu lebih kecil daripada elemen berikutnya
(mengurtkan besar ke kecil) maka proses pertukaran akan
terjadi pada pada baris 23- 25.
- baris 29-32 = Setelah pengurutan berhasil maka nilai akan dicetak/
ditampilkan pada baris ini.

13
 Maka apabila di compile maka hasilnya akan menjadi :

Contoh program bubble sort sederhana

#include “stdio.h”
#include “conio.h”
#include “stdlib.h”

void swap(int &x, int &y);

void bubble_sort(int Array[], int &awal, int &akhir);

void main ()
{
int i, aw, ak, jumdata;
int data[9] = {2,4,6,5,1,7,0,3,8};
aw = 0;
jumdata = sizeof (data) / sizeof (int);
ak = jumdata-1;

printf(“Pengurutan data dengan Bubble Sort\n”);

printf(“\n Sebelum diurutkan :”);

for(i=0; i<jumdata;i++)
printf(“%5d”, data[i]);

bubble_sort(data,aw,ak);

printf(“\n Sesudah diurutkan :”);

for(i=0;i<jumdata;i++)
printf(“%5d”,data[i]);

14
getch();
_exit(0);
}

void bubble_sort(int Array[], int &awal, int &akhir)

{
int i,j,temp;
i=awal;

while (i<akhir) { j=akhir; while(j>i)

{
if(Array[j]<Array[j-i])
{
swap(Array[j-i], Array[j]);
}
j–;
}
i++;
}
}

void swap(int &x, int &y)

{
int temp;
temp = x;
x = y;
y = temp;
}

Output :

15
 BAB III

PENUTUP

3.1 Kesimpulan
Algoritma Bubble Sort adalah algoritma yang simpel dan mudah dipelajari, selain itu
memiliki definisi terurut yang jelas dalam algoritmanya. Algoritma ini juga memiliki
ciri khas, yaitu “kura-kura dan kelinci”. Akan tetapi, algoritma BubbleSort memiliki
kelemahan, yaitu kompleksitas algoritma pada saat mengurutkan data yang sangat
besar akan mengalami kelambatan luar biasa, sehingga menjadikan algoritma ini
tidak efektif dalam pengurutan.

16