E-ISSN 2797-9512

JUTISAL (Jurnal Teknik Informatika Komputer Universal)

P-ISSN 2797-9504

METODE ALGORITMA BUBBLE SORT, ALGORITMA MERGE

SORT DAN ALGORITMA QUICK SORT DALAM PENGUJIAN
PERBANDINGAN PROSES PENELITIAN KUALITATIF
1Harnisah Yohanni Tumanggor, 2Ridha Maya Faza Lubis
3Marulitua Pandapotan Sianturi, 4Ronal Gomar Purba
1,2,3,4
Akademi Manajemen Informatika dan Komputer Universal
e-mail: harnisahyt@gmail.com

ABSTRAK
Peran dalam suatu perangkat lunak sangat dibutuhkan dalam suatu pemograman dalam
memcahkan suatu permasalahan dalam matematika, sehingga banyak yang dibutuhkan
dalam memahami konsep tersebut sehingga dapat memahami dengan baik serta jelas.
Setiap dalam permasalahan pemograman yang sering akan dihadapi yaitu untuk
menentukan algoritma yang memiliki metode paling singkat dan simple untuk melakukan
dalam sebuah pemograman. Dengan adanya penelitian ini, peneliti melakukan
perbandingan terhadap tiga (3) metode yang dilakukan sebagai proses penelitian kualitatif
serta dapat melakukan uji coba dan sebagai contoh untuk kegiatan sederhana dalam
pemograman. Algoritma ketiga (3) tersebut yaitu: Bubble Sort, Merge Sort dan Quick
Sort.
Kata Kunci: Kompleksitas Algoritma, Bubble Sort, Merge Sort, Quick Sort.

ABSTRACT
The role of software is needed in programming in solving a problem in mathematics, so
much is needed in understanding the concept so that it can understand well and clearly.
Every programming problem that will often be faced is to determine the algorithm that
has the shortest and simplest method to perform in programming. With this research, the
researcher compares the three (3) methods carried out as a qualitative research process
and can conduct trials and as examples for simple activities in programming. the three
(3) algorithms are Bubble Sort, Merge Sort and Quick Sort.
Keywords: Algorithm Complexity, Bubble Sort, Merge Sort, Quick Sort.

1. PENDAHULUAN
Beberapa konteks untuk pemograman menggunakan algoritma sangat memudahkan
untuk melakukan penelitian tertentu yang lebih efisien, serta tepat dalam mengolah data.
Algoritma merupakan metode atau langkah yang direncanakan secara tersusun dan
berurutan untuk menyelesaikan atau memecahkan permasalahan dengan sebuah instruksi
atau kegiatan. Perkembangan ilmu pengetahuan dan teknologi menjadikan manusia
mampu menghasilkan karya-karya yang semakin canggih dan serta kompleks. Meskipun
dengan perkembangannya sebuah komputer dapat menghitung dengan cepat dan hasilnya
maksimal, namun computer tidak bisa menyelesaikan masalah begitu saja tanpa diajarkan
oleh manusia melalui urutan langkah-langkah (algoritma) dalam suatu penyelesaian yang
dapat diindetifikasikan terlebih dahulu. Selain dapat digunakan dalam permasalahan

47 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

kehidupan sehari-hari yang membutuhkan sederet proses atau langkah-langkah yang

prosedural [1]
2. METODE PENELITIAN
2.1 Jenis dan Sumber Data
Metode yang digunakan dalam penelitian ini menggunakan logika pemograman
secara manual untuk perhitungan yang disusun agar dapat mudah dipahami serta metode
yang digunakan dalam penelitian ini: mencara sumber-sumber dari penelitian sebelumnya
atau mencari sejumlah informasi seperti buku referensi, jurnal, ataupun sumber lainnya
yang dapat menunjang penelitian ini yang berkaitan dengan ketiga (3) metode yang akan
dibandingkan.
2.2 Algoritma
Algoritma merupakan sebuah proses yang mesti diikuti dalam perhitungan atau
operasi pemecahan masalah. Metode ini dapat dibagi menjadi tiga yaitu, algoritma
sekuensial, perulangan dan percabangan. Seiring dengan perkembangannya zaman saat
ini, berbagai permasalahan kehidupan manusia sehari-hari dapat diselesaikan dengan
lebih mudah dan lebih cepat dalam waktu yang sangat singkat. Suatu Langkah pemecahan
masalah tersebut dengan algoritma. Berdasarkan Kamus Besar Bahasa Indonesia (KBBI)
algoritma merupakan suatu prosedur sistematis untuk memecahkan masalah yang
matematis dalam langkah-langkah terbatas atau urutan logis pengambilan keputusan
untuk pemecahan masalah [2].
2.3 Bubble Sort
Bubble sort merupakan metode pengurutan algoritma dnegan cara melakukan
penukaran data secara terus menurus sampai bisa dipastikan dalam suatu iterasi tertentu
tidak ada lagi perubahan/penukaran. Algoritma ini menggunakan perbandingan dalam
operasi antar elemennya [3].
Berikut ini merupakan gambaran sederhana dari penerapan algoritma bubble sort:
a. Bandingkan nilai data ke-1 dan data ke-2
b. Jika data ke-1 lebih besar dari data ke-2 maka dapat ditukar posisi
c. Kemudian data yang lebih besar tadi dibandingkan dengan data ke-3
d. Lakukan Langkah nomor 2 hingga selesai.
2.4 Merge Sort
Merge Sort merupakana algoritma pengurutan dalam ilmu komputer yang
dirancang untuk memenuhi kebutuhan pengurutan atas suatu rangkaian data yang tidak
memungkinkan untuk ditampung dalam memori komputer karena jumlahnya yang terlalu
besar. Algoritma ini ditemukan oleh John Von Neumann pada tahun 1945. Merge Sort
merupakan salah satu metode dari ke enam metode yang dalam melakukan pengurutan
atau sorting. Metode ini dinamakan Merge Sort atau pengurutan secara menggabungkan
suatu data [4].
Kelebihan Merge Sort:
a. Dibandingkan dengan algoritma lain, Merge Sort sangat termasuk algoritma
yang sangat efisien dalam penggunaannya sebab setiap list selalu dibagi dalam
menjadi list yang lebih kecil, kemudian dapat digabungkan lagi sehingga tidak
peru melakukan banyak perbandingan.
b. Cocok untuk sorting akses datanya yang lambat misalnya seperti tape drive
atau hard disk.
c. Cocok untuk sorting data yang biasanya diakases secara sequentially
(berurutan).
d. Misalnya linked list, tape drive dan hard disk.

48 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

Kekurangan Merge Sort:

a. Kekurangan Merge Sort yaitu terlalu banyak menggunakan ruang pada memori
b. Merge Sort membutuhkan lebih banyak ruang daripada jenis sorting lainnya.
2.5 Quick Sort
Quick Sort merupakan algoritma untuk mengurutkan data dengan pendekatan
rekursif. Proses pengurutan dilakukan dengan memecahkan masalah kumpulan data
menjadi dua bagian berdasarkan nilai pivot yang dipilih. Pada prinsipnya nilai pivot ini
akan ditempatkan pada posisinya disetiap akhir proses partisi. Setelah proses partisi
selesai dan menempatkan pivot pada posisinya yang tepat maka proses pengurutan
dilanjutkan secara rekursif untuk mengurutkan data bagian kiri dari pivot dan bagian
kanan dari pivot tersebut. Kinerja algoritma Quick Sort secara rata-rata adalah O(n log n).
Algoritma Quick Sort cepat dalam praktiknya daripada algoritma Merge Sort dan Heap
Sort [5].
Tabel 1. Perbandingan Merge Sort dan Quick Sort
Dasar Perbandingan Urutan Cepat Gabungkan Urutan
Mempartisi elemen dalam Pemisahan daftar elemen Larik selalu dibagi
array tidak harus dibagi menjadi dua (n/2).
menjadi dua
Kompleksitas kasus Di2) O (n log n)
terburuk
Bekerja dengan baik Array yang lebih kecil Beroperasi dengan baik di
semua jenis larik.
Kecepatan Lebih cepat daripada Kecepatan yang konsisten
algoritma pengurutan lain di semua jenis data.
untuk kumpulan data
kecil
Persyaratan ruang Kurang Lebih
penyimpanan tambahan
Efisiensi Tidak efisien untuk array Lebih efisien.
yang lebih besar
Metode penyotiran intern Luar

3. HASIL DAN PEMBAHASAN

Penelitian ini didapatkan untuk ketiga (3) metode tersebut untuk dibandingkan
berdasarkan contoh hal yang sederhana yang sama efektif yang akan dilakukan dalam
peneliti, yaitu:
a. Bubble Sort
Bubble Sort adalah algoritma pengurutan yang membandingkan dua elemen yang
berdekatan dan menukarnya sampai berada dalam urutan yang diinginkan. Sama seperti
gerakan gelembung di air yang naik ke permukaan, setiap elemen larik bergerak ke ujung
di setiap iterasi. Oleh karena itu, ini disebut dengan Bubble Sort.
Contoh sederhana dari algoritma Bubble Sort, mencoba untuk mengurutkan elemen
dalam urutan menaik [6].

49 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

1. Iterasi Pertama (Bandingkan dan Tukar)

a. Mulai dari indeks pertama, dapat dibandingkan dengan elemen pertama dan
kedua.
b. Jika elemen pertama lebih besar dari elemen kedua, mereka dapat ditukar.
c. Sekarang, bandingkan elemen kedua dan ketiga.
d. Tukarkan jika tidak berurutan.
Proses di atas berlangsung hingga elemen terakhir.
Step = 0
i=0
-2 45 0 11 -9

i=1
-2 45 0 11 -9

i=2
-2 0 45 11 -9

i=3
-2 0 11 45 -9

-2 0 11 -9 45
Membandingkan elemen yang berdekatan.
2. Sisa Iterasi
Proses yang sama berlaku untuk iterasi yang tersisa, setiap iterasi elemen terbesar
diantara elemen yang tidak disortir ditempatkan diakhir.

Step = 1
i=0
-2 0 11 -9 45

i=1
-2 0 11 -9 45

i=2
-2 0 11 -9 45

-2 0 -9 11 45
Letakkan elemen terbesar di akhir.
Dalam setiap iterasi, perbandingan terjadi hingga elemen terakhir yang tidak disortir.

50 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

Step = 2
i=0
-2 0 -9 11 45
i=1
-2 0 -9 11 45

-2 -9 0 11 45
Bandingkan elemen yang berdekatan.
Array diurutkan ketika semua elemen yang tidak disortir ditempatkan pada posisi yang
benar.

Step = 3
i=0
-2 -9 0 11 45

-9 -2 0 11 45
Array diurutkan jika semua elemen disimpan dalam urutan yang benar.

Tabel 2. Algoritma Bubble Sort

bubbleSort(array) Bubble sort in Python
for i <- 1 to
indexOfLastUnsortedElement-1 def bubbleSort(array):
if leftElement > rightElement
swap leftElement and rightElement # loop to access each array element
end bubbleSort for i in range(len(array)):

# loop to compare array elements

for j in range(0, len(array) - i - 1):

# compare two adjacent elements

# change > to < to sort in descending
order
if array[j] > array[j + 1]:

# swapping elements if elements

# are not in the intended order
temp = array[j]
array[j] = array[j+1]
array[j+1] = temp

data = [-2, 45, 0, 11, -9]

bubbleSort(data)

51 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

print('Sorted Array in Ascending Order:')

print(data)

b. Merge Sort
Merge Sort adalah salah satu algoritma pengurutan paling populer yang
didasarkan pada prinsip Algoritma Divide dan Conquer. Permasalahan dibagi menjadi
beberapa sub-masalah. Setiap sub-masalah diselesaikan secara individual. Akhirnya, sub-
masalah digabungkan untuk membentuk solusi akhir [7].

Algoritma Merge Sort

Fungsi Merge Sort berulang kali membagi array menjadi dua bagian sampai
mencapai tahap di mana mencoba untuk melakukan Merge Sort pada subarray ukuran 1
yaitu p == r. Setelah itu, fungsi merge mulai dimainkan dan menggabungkan array yang
diurutkan menjadi array yang lebih besar hingga seluruh array digabungkan [8]:

MergeSort(A, p, r): / Merge two subarrays L and M into arr

if p > r void merge(int arr[], int p, int q, int r) {
return
q = (p+r)/2 // Create L ← A[p..q] and M ←
mergeSort(A, p, q) A[q+1..r]
mergeSort(A, q+1, r) int n1 = q - p + 1;
merge(A, p, q, r) int n2 = r - q;

int L[n1], M[n2];

for (int i = 0; i < n1; i++)

L[i] = arr[p + i];
for (int j = 0; j < n2; j++)
M[j] = arr[q + 1 + j];

// Maintain current index of sub-arrays

and main array
int i, j, k;

52 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

i = 0;
j = 0;
k = p;

// Until we reach either end of either L

or M, pick larger among
// elements L and M and place them in
the correct position at A[p..r]
while (i < n1 && j < n2) {
if (L[i] <= M[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = M[j];
j++;
}
k++;
}

// When we run out of elements in

either L or M,
// pick up the remaining elements and
put in A[p..r]
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}

while (j < n2) {

arr[k] = M[j];
j++;
k++;
}
}
void merge(int arr[], int p, int q, int r) { // Create L ← A[p..q] and M ← A[q+1..r]
// Here, p = 0, q = 4, r = 6 (size of array) int n1 = q - p + 1 = 3 - 0 + 1 = 4;
int n2 = r - q = 5 - 3 = 2;

int L[4], M[2];

for (int i = 0; i < 4; i++)

L[i] = arr[p + i];
// L[0,1,2,3] = A[0,1,2,3] =
[1,5,10,12]

for (int j = 0; j < 2; j++)

M[j] = arr[q + 1 + j];

53 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

// M[0,1] = A[4,5] = [6,9]

int i, j, k; while (i < n1 && j < n2) {
i = 0; if (L[i] <= M[j]) {
j = 0; arr[k] = L[i]; i++;
k = p; }
else {
arr[k] = M[j];
j++;
}
k++;
}
// We exited the earlier loop because j < // We exited the earlier loop because i <
n2 doesn't hold n1 doesn't hold
while (i < n1) while (j < n2)
{ {
arr[k] = L[i]; arr[k] = M[j];
i++; j++;
k++; k++;
} }
}
# MergeSort in Python

def mergeSort(array):
if len(array) > 1:

# r is the point where the array is divided into two subarrays

r = len(array)//2
L = array[:r]
M = array[r:]

# Sort the two halves

mergeSort(L)
mergeSort(M)

i=j=k=0

# Until we reach either end of either L or M, pick larger among

# elements L and M and place them in the correct position at A[p..r]
while i < len(L) and j < len(M):
if L[i] < M[j]:
array[k] = L[i]
i += 1
else:
array[k] = M[j]
j += 1
k += 1

54 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

# When we run out of elements in either L or M,

# pick up the remaining elements and put in A[p..r]
while i < len(L):
array[k] = L[i]
i += 1
k += 1

while j < len(M):

array[k] = M[j]
j += 1
k += 1

# Print the array

def printList(array):
for i in range(len(array)):
print(array[i], end=" ")
print()

# Driver program
if _name_ == '_main_':
array = [6, 5, 12, 10, 9, 1]

mergeSort(array)

print("Sorted array is: ")

printList(array)

c. Quick Sort
Quick Sort adalah algoritma pengurutan berdasarkan pendekatan membagi dan
menaklukkan di mana array dibagi menjadi sub array dengan memilih elemen pivot
(elemen dipilih dari array). Saat membagi array, elemen pivot harus diposisikan
sedemikian rupa sehingga elemen yang lebih kecil dari pivot disimpan di sisi kiri dan
elemen yang lebih besar dari pivot berada di sisi kanan pivot. Sub array kiri dan kanan
juga dibagi menggunakan pendekatan yang sama. Proses ini berlanjut hingga setiap sub
array berisi satu elemen. Pada titik ini, elemen sudah diurutkan. Akhirnya, elemen
digabungkan untuk membentuk array yang diurutkan [9].

quickSort(array, leftmostIndex, # Quick sort in Python

rightmostIndex)
if (leftmostIndex < rightmostIndex) # function to find the partition position
pivotIndex <- def partition(array, low, high):
partition(array,leftmostIndex,
rightmostIndex) # choose the rightmost element as pivot
quickSort(array, leftmostIndex, pivot = array[high]
pivotIndex - 1)
# pointer for greater element

55 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

quickSort(array, pivotIndex, i = low - 1

rightmostIndex)
# traverse through all elements
partition(array, leftmostIndex, # compare each element with pivot
rightmostIndex) for j in range(low, high):
set rightmostIndex as pivotIndex if array[j] <= pivot:
storeIndex <- leftmostIndex - 1 # if element smaller than pivot is
for i <- leftmostIndex + 1 to found
rightmostIndex # swap it with the greater element
if element[i] < pivotElement pointed by i
swap element[i] and i=i+1
element[storeIndex]
storeIndex++ # swapping element at i with element
swap pivotElement and at j
element[storeIndex+1] (array[i], array[j]) = (array[j],
return storeIndex + 1 array[i])

# swap the pivot element with the

greater element specified by i
(array[i + 1], array[high]) =
(array[high], array[i + 1])

# return the position from where

partition is done
return i + 1

# function to perform quicksort

def quickSort(array, low, high):
if low < high:

# find pivot element such that

# element smaller than pivot are on the
left
# element greater than pivot are on the
right
pi = partition(array, low, high)

# recursive call on the left of pivot

quickSort(array, low, pi - 1)

# recursive call on the right of pivot

quickSort(array, pi + 1, high)

data = [8, 7, 2, 1, 0, 9, 6]
print("Unsorted Array")
print(data)

56 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

size = len(data)

quickSort(data, 0, size - 1)

print('Sorted Array in Ascending

Order:')
print(data)

4. KESIMPULAN
Berdasarkan pengujian untuk ketiga algoritma tersebut yang diuji dengan
menggunakan algoritma Bubble Sort dari penyelesaian dapat melakukan hingga 10
kecepatan putaran dan dapat dibandingkan denfan 15 kali pebandingan yang dapat
dirumuskan dengan nilai n dengan n-1 sehingga dapat diurutkan data yang memiliki hasil
yang sangat maksimal. Sedangkan algoritma Quick Sort dapat menyelesaikan secara
rekursif diperoleh dengan hasil rekursif 25 kali.

DAFTAR PUSTAKA
1. J. S. Komputer, N. Arifin, and U. Nasional, “Kombinasi Algoritma Sequential
Searching dan Bubble Sort Pada Manajemen Laboratorium,” vol. 6, no. 3, pp.
294–306, 2022.
2. A. Sonita and F. Nurtaneo, “Analisis Perbandingan Algoritma Bubble Sort, Merge
Sort, Dan Quick Sort Dalam Proses Pengurutan Kombinasi Angka Dan Huruf,”
Pseudocode, vol. 2, no. 2, pp. 75–80, 2016, doi: 10.33369/pseudocode.2.2.75-80.
3. D. Setyantoro and R. A. Hasibuan, “Analisis Dan Perbandingan Kompleksitas
Algoritma Exchange Sort Dan Insertion Sort Untuk Pengurutan Data
Menggunakan Python,” Tekinfo, vol. 21, no. 1, pp. 48–56, 2020, [Online].
Available: https://journals.upi-yai.ac.id/index.php/TEKINFO/article/view/1139.
4. D. S. Rita Wahyuni Arifin, “Algoritma Metode Pengurutan Bubble Sort dan
Quick Dalam Bahasa Pemrograman C++,” Inf. Syst. Educ. Prof., vol. 4, no. 2, pp.
178–187, 2020.
5. M. A. Pratama, A. Desiani, and Irmeilyana, “Analisis Kebutuhan Waktu
Algoritma InsertionSort, Merge Sort, dan Quick Sort denganKompleksitas
Waktu,” Comput. Sci. ICT, vol. ISBN, no. 1, pp. 31–34, 2017.
6. S. Waruwu, A. S. Sembiring, and ..., “Penerapan Algoritma Quick Pivot Sort Dan
Radix Sort Pada Data Buku,” Pelita Inform. …, vol. 8, pp. 254–257, 2019,
[Online]. Available: http://ejurnal.stmik-
budidarma.ac.id/index.php/pelita/article/view/1837.
7. D. R. Poetra, “Performa Algoritma Bubble Sort dan Quick Sort pada Framework
Flutter dan Dart SDK(Studi Kasus Aplikasi E-Commerce),” JATISI (Jurnal Tek.
Inform. dan Sist. Informasi), vol. 9, no. 2, pp. 806–816, 2022, doi:
10.35957/jatisi.v9i2.1886.
8. N. Sari, W. A. Gunawan, P. K. Sari, I. Zikri, and A. Syahputra, “Analisis
Algoritma Bubble Sort Secara Ascending Dan Descending Serta Implementasinya
Dengan Menggunakan Bahasa Pemrograman Java,” ADI Bisnis Digit.
Interdisiplin J., vol. 3, no. 1, pp. 16–23, 2022, doi: 10.34306/abdi.v3i1.625.
9. D. Y. Rizki Saputra, S. Andryana, and I. D. Sholihati, “Analisis Perbandingan
Algoritma Bubble Sort Dan Selection Sort Pada Sistem Pendukung Keputusan
Pemilihan Tempat Kost Berbasis Ios (Iphone Operating System),” JIPI (Jurnal

57 Vol. 2 No. 2 Edisi Desember 2022

 E-ISSN 2797-9512
JUTISAL (Jurnal Teknik Informatika Komputer Universal)
P-ISSN 2797-9504

Ilm. Penelit. dan Pembelajaran Inform., vol. 6, no. 2, pp. 318–324, 2021, doi:
10.29100/jipi.v6i2.2015.

58 Vol. 2 No. 2 Edisi Desember 2022