Bubble Sort dan Quick Sort: Panduan Lengkap Python

Kalau kamu lagi belajar struktur data dan algoritma, dua nama ini pasti bakal ketemu duluan: bubble sort dan quick sort. Keduanya sama-sama dipakai buat mengurutkan data, tapi caranya beda jauh dan dampaknya ke performa program juga beda banget. Di tulisan ini kita bakal bongkar cara kerja bubble sort dan quick sort dari nol, lengkap dengan kode Python yang bisa langsung kamu coba, studi kasus nyata, sampai perbandingan performa biar kamu tahu kapan harus pakai yang mana.

Apa Itu Algoritma Sorting, dan Kenapa Bubble Sort sama Quick Sort Layak Kamu Kuasai

Algoritma sorting adalah prosedur yang mengatur ulang kumpulan data supaya urutannya sesuai aturan tertentu, biasanya dari kecil ke besar atau sebaliknya.

Kedengarannya sepele, tapi hampir semua sistem yang kamu pakai sehari-hari bergantung sama proses ini. Aplikasi e-commerce ngurutin produk berdasarkan harga, aplikasi musik ngurutin lagu berdasarkan judul, bahkan database ngurutin data biar pencarian jadi cepat.

Beberapa alasan kenapa memahami sorting itu bukan cuma teori kosong:

• Organisasi data jadi lebih rapi. Data yang terurut lebih gampang dicari, dibandingkan, dan dianalisis.

• Efisiensi program. Algoritma sorting yang tepat bisa bikin aplikasi kamu jauh lebih cepat, apalagi kalau datanya besar.

• Bekal buat interview kerja. Pertanyaan soal sorting hampir selalu muncul di technical interview, entah di perusahaan rintisan atau korporasi besar.

• Melatih cara berpikir algoritmis. Begitu kamu paham bubble sort dan quick sort, kamu bakal lebih gampang nangkep konsep algoritma lain kayak searching atau dynamic programming.

Nah, dari sekian banyak algoritma sorting yang ada, bubble sort dan quick sort ini semacam dua kutub yang berlawanan. Bubble sort itu simpel banget tapi lambat, sementara quick sort agak rumit di awal tapi larinya kencang. Justru karena kontras inilah keduanya jadi kombinasi belajar yang pas.

Kenalan Dulu Sama Bubble Sort

Bubble sort adalah algoritma sorting yang bekerja dengan membandingkan dua elemen yang bersebelahan, lalu menukar posisinya kalau urutannya salah, diulang terus sampai seluruh data terurut.

Namanya "bubble" (gelembung) karena elemen dengan nilai besar itu perlahan-lahan "naik" ke posisi paling akhir, mirip gelembung udara yang naik ke permukaan air. Analogi ini kelihatan sederhana, tapi cukup ngena buat ngebayangin gimana algoritma ini bergerak.

Cara Kerja Bubble Sort

1. Mulai dari elemen pertama array.

2. Bandingkan dengan elemen di sebelahnya.

3. Kalau elemen pertama lebih besar, tukar posisinya.

4. Geser ke pasangan berikutnya, ulangi langkah 2 dan 3.

5. Setelah satu putaran penuh, elemen terbesar bakal "mendarat" di posisi paling akhir.

6. Ulangi seluruh proses ini, tapi kali ini abaikan elemen terakhir yang sudah pasti benar posisinya.

7. Berhenti kalau sudah tidak ada lagi pertukaran yang terjadi.

Poin nomor 7 ini penting banget, dan nanti kita bahas kenapa di bagian optimasi.

Kompleksitas Waktu Bubble Sort

Kompleksitas O(n²) ini artinya kalau jumlah data naik dua kali lipat, waktu prosesnya bisa naik sampai empat kali lipat. Bayangin kalau datanya jutaan baris, bubble sort bisa bikin aplikasi kamu ngadat.

Terus, Apa Itu Quick Sort?

Quick sort adalah algoritma sorting berbasis strategi divide and conquer (bagi dan taklukkan) yang memilih satu elemen sebagai pivot, lalu membagi data jadi dua bagian berdasarkan pivot tersebut secara rekursif.

Kalau bubble sort kerjanya "sabar" ngebandingin satu-satu, quick sort lebih cerdik. Dia milih satu angka jadi patokan (pivot), terus misahin data jadi dua kelompok: yang lebih kecil dari pivot di satu sisi, yang lebih besar di sisi lain. Proses ini diulang terus buat tiap kelompok kecil sampai semuanya terurut.

Cara Kerja Quick Sort

1. Pilih satu elemen dari array sebagai pivot.

2. Bagi elemen lain jadi dua kelompok: lebih kecil dari pivot dan lebih besar dari pivot (proses ini disebut partitioning).

3. Taruh pivot di posisi yang sudah pasti benar, di antara dua kelompok tadi.

4. Lakukan proses yang sama secara rekursif ke masing-masing kelompok, sampai ukurannya tinggal 0 atau 1 elemen.

Karena sifatnya rekursif, quick sort itu memanggil dirinya sendiri berkali-kali dengan potongan data yang makin kecil. Kalau kamu belum familier sama konsep rekursi, bayangin aja kayak boneka matryoshka—satu masalah besar dipecah jadi masalah yang lebih kecil dengan pola yang sama, sampai ketemu masalah paling sederhana yang bisa langsung diselesaikan.

Kompleksitas Waktu Quick Sort

Bandingkan dengan bubble sort: di kasus rata-rata, quick sort jauh lebih ngebut karena kompleksitas O(n log n) tumbuh jauh lebih lambat dibanding O(n²) seiring bertambahnya data.

Yang Perlu Kamu Siapkan Sebelum Praktik

Sebelum masuk ke kode, ada beberapa hal yang sebaiknya kamu punya dulu biar tutorial ini nyambung:

• Python terpasang di komputer. Tutorial ini pakai Python karena sintaksnya ringkas dan gampang dibaca, tapi konsepnya berlaku juga di JavaScript, Java, C++, atau bahasa lain.

• Text editor atau IDE. VS Code, PyCharm, atau bahkan Notepad juga cukup, yang penting kamu nyaman.

• Pemahaman dasar soal list/array. Kamu perlu tahu cara mengakses elemen lewat index, misalnya data[0] untuk elemen pertama.

• Konsep perulangan (loop). Bubble sort dan quick sort sama-sama mengandalkan for dan pengulangan bersarang.

• Sedikit pemahaman soal fungsi dan rekursi. Khusus buat quick sort, kamu perlu tahu bahwa sebuah fungsi bisa memanggil dirinya sendiri.

Kalau semua poin di atas sudah kamu kuasai, kamu siap lanjut ke bagian praktik.

Langkah 1: Siapkan Struktur Proyek dan Data Uji

Buat folder baru, misalnya belajar-sorting, lalu buat file sorting.py di dalamnya. Ini bakal jadi tempat kita nulis dan menguji kedua algoritma.

Langkah pertama sebelum menulis algoritma apa pun adalah menyiapkan data yang mau diurutkan. Ini penting karena kamu butuh data yang konsisten buat membandingkan hasil sebelum dan sesudah sorting.

# sorting.py
data_uji = [64, 34, 25, 12, 22, 11, 90]
print("Data awal:", data_uji)

Kenapa langkah ini penting? Karena tanpa data uji yang jelas, kamu bakal susah memverifikasi apakah fungsi sorting yang kamu buat benar-benar bekerja atau malah merusak data.

Langkah 2: Tulis Fungsi Bubble Sort dari Nol

Sekarang kita bangun bubble sort selangkah demi selangkah. Mulai dari perulangan luar yang menentukan berapa kali kita perlu "menyapu" seluruh array.

def bubble_sort(data):
    n = len(data)
    for i in range(n - 1):
        # perulangan luar: menentukan jumlah putaran
        pass
    return data

Perulangan luar berjalan n - 1 kali karena setelah n - 1 putaran, elemen terakhir yang tersisa otomatis sudah di posisi yang benar. Ini bukan angka asal-asalan, ini hasil dari logika bahwa tiap putaran memastikan satu elemen terbesar "mendarat" di ujung.

Selanjutnya, tambahkan perulangan dalam yang benar-benar melakukan perbandingan dan penukaran:

def bubble_sort(data):
    n = len(data)
    for i in range(n - 1):
        for j in range(n - i - 1):
            if data[j] > data[j + 1]:
                data[j], data[j + 1] = data[j + 1], data[j]
    return data

Perhatikan n - i - 1 di perulangan dalam. Ini penting karena setiap putaran, elemen paling belakang sudah pasti benar, jadi nggak perlu dicek ulang. Kalau kamu salah tulis jadi n - 1 tanpa dikurangi i, program tetap jalan tapi jadi boros—dia bakal ngecek ulang elemen yang sebenarnya sudah beres.

Baca juga OpenCode Free: Agen AI Coding Gratis dan Open Source

Baris data[j], data[j + 1] = data[j + 1], data[j] adalah cara Python untuk menukar dua nilai tanpa perlu variabel bantuan. Di bahasa lain seperti Java atau C, kamu biasanya perlu variabel temp buat nyimpen nilai sementara.

Coba jalankan:

angka = [64, 34, 25, 12, 22, 11, 90]
print("Sebelum:", angka)
print("Sesudah:", bubble_sort(angka))

Output yang diharapkan:

Sebelum: [64, 34, 25, 12, 22, 11, 90]
Sesudah: [11, 12, 22, 25, 34, 64, 90]

Kalau output kamu persis kayak gitu, berarti fungsi bubble sort kamu udah bener.

Langkah 3: Optimasi Bubble Sort Biar Nggak Buang-Buang Waktu

Versi bubble sort di atas sebenarnya masih "bodoh". Dia tetap ngelakuin semua putaran meskipun data udah keburu terurut di tengah jalan. Ini boros dan nggak perlu.

Solusinya, tambahkan penanda swapped buat mendeteksi apakah ada pertukaran di satu putaran penuh. Kalau nggak ada pertukaran sama sekali, artinya data udah terurut dan proses bisa dihentikan lebih awal.

def bubble_sort(data):
    n = len(data)
    for i in range(n - 1):
        swapped = False
        for j in range(n - i - 1):
            if data[j] > data[j + 1]:
                data[j], data[j + 1] = data[j + 1], data[j]
                swapped = True
        if not swapped:
            break
    return data

Kenapa optimasi ini penting? Karena di kasus terbaik—data yang sudah terurut—versi ini cuma butuh satu putaran, alias kompleksitas waktunya turun jadi O(n) alih-alih tetap O(n²). Lumayan banget buat data yang hampir terurut, misalnya log transaksi harian yang cuma nambah beberapa baris baru.

Langkah 4: Tulis Fungsi Quick Sort

Sekarang kita masuk ke quick sort. Versi paling gampang dipahami adalah versi yang memakai list comprehension di Python, meskipun bukan yang paling hemat memori.

def quick_sort(data):
    if len(data) <= 1:
        return data
    pivot = data[len(data) // 2]
    kiri = [x for x in data if x < pivot]
    tengah = [x for x in data if x == pivot]
    kanan = [x for x in data if x > pivot]
    return quick_sort(kiri) + tengah + quick_sort(kanan)

Mari kita bedah kenapa tiap baris ada di situ:

• if len(data) <= 1: return data adalah base case, alias kondisi berhenti. Tanpa ini, fungsi bakal manggil dirinya sendiri terus-menerus sampai program crash. Ini kesalahan paling umum yang bikin pemrograman rekursif berujung error.

• pivot = data[len(data) // 2] memilih elemen tengah sebagai pivot. Memilih elemen tengah (bukan elemen pertama atau terakhir) membantu menghindari kasus terburuk pada data yang sudah terurut.

• kiri, tengah, dan kanan memisahkan data berdasarkan perbandingan dengan pivot. Variabel tengah sengaja dipisah biar bisa menampung elemen duplikat yang nilainya sama persis dengan pivot.

• Baris terakhir menggabungkan hasil rekursi dari kiri, elemen tengah, dan hasil rekursi dari kanan, lalu mengembalikannya sebagai satu list yang sudah terurut.

Coba jalankan:

angka = [29, 10, 14, 37, 13]
print("Sebelum:", angka)
print("Sesudah:", quick_sort(angka))

Output yang diharapkan:

Sebelum: [29, 10, 14, 37, 13]
Sesudah: [10, 13, 14, 29, 37]

Langkah 5: Coba Versi Quick Sort In-Place (Lebih Hemat Memori)

Versi quick sort dengan list comprehension gampang dibaca, tapi boros memori karena tiap rekursi bikin list baru. Versi yang lebih umum dipakai di dunia nyata adalah versi in-place, yang mengubah array asli langsung tanpa bikin salinan baru.

def partition(data, low, high):
    pivot = data[high]
    i = low - 1
    for j in range(low, high):
        if data[j] <= pivot:
            i += 1
            data[i], data[j] = data[j], data[i]
    data[i + 1], data[high] = data[high], data[i + 1]
    return i + 1

def quick_sort_in_place(data, low=0, high=None):
    if high is None:
        high = len(data) - 1
    if low < high:
        pos_pivot = partition(data, low, high)
        quick_sort_in_place(data, low, pos_pivot - 1)
        quick_sort_in_place(data, pos_pivot + 1, high)
    return data

Fungsi partition di sini memakai pivot elemen terakhir, lalu menata ulang array supaya semua elemen yang lebih kecil dari pivot ada di sebelah kiri. Ini disebut Lomuto partition scheme, salah satu pendekatan yang paling sering diajarkan.

angka = [10, 7, 8, 9, 1, 5]
print("Sesudah:", quick_sort_in_place(angka))

Output yang diharapkan:

Sesudah: [1, 5, 7, 8, 9, 10]

Versi ini lebih hemat memori (kompleksitas ruang O(log n) karena hanya menyimpan pemanggilan rekursi, bukan salinan array baru), tapi memang sedikit lebih rumit dibaca dibanding versi list comprehension.

Kesalahan Umum dan Cara Mengatasinya

Sepanjang aku ngajarin dan nyoba-nyoba sendiri kedua algoritma ini, ada beberapa kesalahan yang hampir selalu muncul. Berikut daftarnya biar kamu nggak kejebak hal yang sama.

1. IndexError: list index out of range

Biasanya muncul di bubble sort kalau batas perulangan dalam salah, misalnya kamu nulis range(n) bukan range(n - i - 1), sehingga data[j + 1] mencoba mengakses index yang nggak ada.

Cara mengatasi: pastikan batas atas perulangan selalu n - i - 1, dan selalu bandingkan data[j] dengan data[j + 1], bukan data[j + 1] dengan data[j + 2].

2. RecursionError: maximum recursion depth exceeded

Ini kesalahan khas quick sort. Biasanya terjadi kalau:

• Kamu lupa nulis base case (if len(data) <= 1: return data).

• Data yang diurutkan sudah dalam keadaan terurut atau terbalik, dan kamu memilih pivot dari elemen pertama atau terakhir, sehingga pembagian data jadi timpang dan rekursi jadi sangat dalam.

Cara mengatasi: selalu cek ulang base case-nya, dan pertimbangkan memilih pivot secara acak (random pivot) atau pakai elemen tengah supaya pembagian data lebih seimbang.

Baca juga ClinePass: Langganan Model Open Weight untuk Coding

3. Data Malah Jadi Berantakan Setelah Di-sort

Biasanya ini terjadi karena kamu salah nempatin tanda > atau < di kondisi perbandingan. Kalau kamu mau urutan menurun (descending), tinggal balik tanda perbandingannya.

# Bubble sort urutan menurun
if data[j] < data[j + 1]:
    data[j], data[j + 1] = data[j + 1], data[j]

4. TypeError: '>' not supported between instances of 'str' and 'int'

Muncul kalau list yang kamu urutkan berisi campuran tipe data, misalnya angka dan teks dalam satu list. Python nggak bisa membandingkan 5 dengan "lima" secara langsung.

Cara mengatasi: pastikan semua elemen dalam list punya tipe data yang sama, atau lakukan konversi tipe data sebelum sorting.

5. Lupa Return Value dari Fungsi Rekursif

Kesalahan yang sering luput: di dalam fungsi rekursif seperti quick sort, kamu harus benar-benar return hasil pemanggilan rekursifnya, bukan cuma memanggilnya tanpa menyimpan hasilnya. Kalau kamu tulis quick_sort(kiri) tanpa return, hasilnya bakal None dan bikin error aneh di baris penggabungan list.

Studi Kasus: Ketika Aku Harus Memilih Algoritma Sorting yang Tepat

Latar Belakang

Beberapa waktu lalu aku pernah bantuin proyek kecil, semacam sistem manajemen inventaris sederhana buat toko online. Sistem ini perlu menampilkan daftar produk terurut berdasarkan harga, dan datanya terus bertambah setiap hari.

Tantangan

Awalnya aku asal pakai bubble sort karena implementasinya paling cepat aku tulis. Semuanya lancar waktu data masih di bawah seratus item. Tapi begitu jumlah produk menembus belasan ribu, halaman katalog jadi lemot banget setiap kali ada filter harga yang di-refresh.

Pendekatan

Aku coba ukur waktu eksekusi pakai modul time di Python buat bandingin bubble sort versus quick sort dengan jumlah data yang sama.

import time
import random

data_besar = [random.randint(1, 100000) for _ in range(5000)]

data_bubble = data_besar.copy()
mulai = time.time()
bubble_sort(data_bubble)
print("Bubble sort:", time.time() - mulai, "detik")

data_quick = data_besar.copy()
mulai = time.time()
quick_sort(data_quick)
print("Quick sort:", time.time() - mulai, "detik")

Implementasi

Setelah lihat hasilnya, aku ganti fungsi sorting di bagian katalog produk dari bubble sort manual ke quick sort. Tapi ternyata, setelah dicek lebih lanjut, ternyata solusi paling praktis buat kasus produksi adalah memakai fungsi sorted() bawaan Python, yang di baliknya memakai algoritma Timsort—gabungan antara insertion sort dan merge sort yang dioptimasi khusus buat data dunia nyata.

Hasil

Dari pengujian kasar di komputer aku sendiri dengan 5.000 data acak:

Angka persisnya bakal berbeda tergantung spesifikasi komputer kamu, tapi polanya konsisten: makin besar datanya, makin kelihatan jomplang selisih antara bubble sort dan quick sort.

Pembelajaran Utama

• Bubble sort itu oke banget buat belajar konsep, tapi jangan dipakai di sistem produksi dengan data besar.

• Quick sort jauh lebih scalable, tapi tetap ada risiko kasus terburuk kalau pemilihan pivot-nya kurang cerdas.

• Buat kebutuhan produksi sehari-hari, memakai fungsi sorting bawaan bahasa pemrograman (seperti sorted() di Python atau Arrays.sort() di Java) biasanya jadi pilihan paling aman, karena sudah dioptimasi bertahun-tahun oleh banyak kontributor.

Bubble Sort vs Quick Sort: Perbandingan Lengkap

Biar makin jelas, berikut tabel perbandingan menyeluruh antara dua algoritma ini.

Kriteria Kecepatan

Quick sort jauh lebih unggul di kasus rata-rata karena kompleksitas O(n log n) tumbuh jauh lebih lambat dibanding O(n²) milik bubble sort. Semakin banyak datanya, semakin terasa bedanya.

Kriteria Stabilitas

Stabilitas dalam konteks sorting berarti elemen dengan nilai yang sama tetap mempertahankan urutan relatifnya sebelum dan sesudah di-sort. Bubble sort itu stabil karena penukaran cuma terjadi antar elemen bersebelahan, sedangkan quick sort standar nggak menjamin ini karena proses partisinya bisa memindahkan elemen yang nilainya sama ke posisi berbeda.

Stabilitas ini penting kalau kamu, misalnya, ngurutin daftar siswa berdasarkan nilai, tapi mau nama-nama dengan nilai yang sama tetap muncul sesuai urutan abjad yang sudah ditata sebelumnya.

Baca juga Kiro Dev: IDE Agentic AWS untuk Spec-Driven Development

Kriteria Penggunaan Memori

Bubble sort itu in-place sepenuhnya, cuma butuh memori tambahan yang konstan (O(1)). Quick sort versi in-place butuh memori tambahan sebesar O(log n) buat menyimpan pemanggilan rekursi, sementara versi list comprehension yang kita tulis di atas justru cukup boros memori karena bikin list baru di setiap pemanggilan.

Kapan Harus Pakai yang Mana?

• Pakai bubble sort kalau: kamu lagi belajar konsep dasar algoritma, ukuran datanya kecil (di bawah ratusan elemen), atau kamu butuh kode yang gampang banget dijelaskan ke orang lain.

• Pakai quick sort kalau: datamu berjumlah ribuan sampai jutaan elemen, performa jadi prioritas utama, dan kamu nggak terlalu peduli soal stabilitas urutan elemen yang sama.

• Pakai fungsi sorting bawaan bahasa pemrograman kalau: kamu lagi ngerjain proyek produksi sungguhan. Hampir semua bahasa modern punya algoritma sorting bawaan yang sudah teruji dan dioptimasi, jadi nggak perlu nulis ulang dari nol kecuali untuk keperluan belajar.

Kelebihan dan Kekurangan Masing-Masing

Bubble Sort

Kelebihan:

• Sangat mudah dipahami, cocok buat memahami konsep dasar perbandingan dan penukaran.

• Implementasinya singkat, cuma butuh beberapa baris kode.

• Bersifat stabil.

• Tidak butuh memori tambahan.

Kekurangan:

• Sangat lambat untuk data besar karena kompleksitas O(n²).

• Nyaris tidak ada kegunaan praktis di sistem produksi modern.

Paling cocok buat: kamu yang baru belajar algoritma dan struktur data, atau dosen/pengajar yang butuh contoh sederhana buat menjelaskan konsep sorting.

Sebaiknya dilewati kalau: kamu sedang mengerjakan proyek dengan data besar atau butuh performa tinggi.

Quick Sort

Kelebihan:

• Sangat cepat di kasus rata-rata, salah satu algoritma sorting tercepat secara praktis.

• Bisa diimplementasikan secara in-place sehingga hemat memori.

• Banyak dipakai sebagai dasar algoritma sorting bawaan di berbagai bahasa pemrograman.

Kekurangan:

• Kasus terburuknya tetap O(n²), meskipun jarang terjadi kalau pemilihan pivot dilakukan dengan baik.

• Implementasinya sedikit lebih rumit, terutama versi in-place.

• Umumnya tidak stabil.

Paling cocok buat: kamu yang butuh performa tinggi untuk data besar, atau sedang membangun fondasi pemahaman sebelum mempelajari algoritma sorting bawaan bahasa pemrograman.

Sebaiknya dilewati kalau: kamu butuh jaminan stabilitas urutan, atau baru pertama kali belajar rekursi dan butuh contoh yang lebih sederhana dulu sebelum lompat ke sini.

Verdict: kalau harus milih satu buat dipahami lebih dalam, quick sort adalah investasi belajar yang lebih berharga karena prinsip divide and conquer-nya dipakai di banyak algoritma lain, bukan cuma sorting.

Tips Tambahan Biar Makin Jago Sorting

• Visualisasikan prosesnya. Ada banyak tool visualisasi online yang menampilkan animasi bubble sort dan quick sort secara real-time. Ngeliat langsung gimana elemen bertukar posisi jauh lebih ngena dibanding cuma baca kode.

• Coba tulis ulang tanpa contekan. Setelah paham dari tutorial ini, coba tutup kode di atas dan tulis ulang fungsi bubble sort dan quick sort dari ingatan kamu sendiri.

• Uji dengan berbagai kondisi data. Coba jalankan fungsi kamu dengan data yang sudah terurut, data terbalik, data dengan banyak duplikat, dan data acak. Ini bakal membantu kamu memahami kenapa kompleksitas waktu bisa berbeda-beda tergantung kondisi data.

• Bandingkan dengan fungsi bawaan. Selalu bandingkan hasil kode buatanmu dengan hasil sorted() di Python biar kamu yakin implementasimu benar.

• Pahami trade-off, bukan cuma hafalan. Daripada menghafal tabel kompleksitas, coba pahami kenapa angkanya bisa segitu. Pemahaman ini bakal lebih nempel dan berguna waktu kamu ketemu algoritma sorting lain seperti merge sort atau heap sort.

• Gabung ke komunitas developer. Kalau kamu di Indonesia, banyak komunitas developer lokal—baik di Jakarta, Bandung, Yogyakarta, Surabaya, atau kota lainnya—yang rutin bikin diskusi soal algoritma dan struktur data lewat forum online maupun meetup. Diskusi kayak gini sering banget bikin pemahaman kamu makin dalam karena kamu dipaksa menjelaskan ulang ke orang lain.

Kalau kamu penasaran soal detail teori dan sejarah algoritma ini, referensi seperti halaman bubble sort di Wikipedia dan quicksort di Wikipedia bisa jadi bacaan tambahan yang cukup lengkap. Buat yang mau lihat gimana Python sendiri mengimplementasikan sorting bawaannya, dokumentasi resmi di docs.python.org juga menjelaskan algoritma Timsort yang dipakai di balik fungsi sorted().

Pertanyaan yang Sering Muncul Soal Bubble Sort dan Quick Sort

Sebelum lanjut ke bagian yang lebih teknis, ada baiknya kita beresin dulu beberapa pertanyaan yang biasanya muncul di kepala orang yang baru ketemu dua algoritma ini. Aku ngumpulin pertanyaan-pertanyaan ini dari pengalaman ngobrol sama teman-teman yang lagi belajar struktur data, jadi kemungkinan besar kamu juga kepikiran hal yang sama.

Apakah Bubble Sort Masih Dipakai di Industri?

Jujur, hampir nggak ada. Kamu bakal susah nemuin bubble sort dipakai di aplikasi produksi sungguhan, kecuali di kasus yang sangat spesifik kayak mengurutkan data yang jumlahnya cuma segelintir dan hampir selalu sudah terurut duluan. Nilai bubble sort sekarang lebih ke sisi edukasi—dia jadi jembatan buat memahami konsep dasar sebelum lompat ke algoritma yang lebih rumit. Kalau kamu ditanya soal ini waktu interview kerja, jawaban yang paling aman adalah mengakui keterbatasannya sambil menjelaskan kenapa algoritma lain seperti quick sort atau Timsort lebih dipilih di dunia nyata.

Kenapa Quick Sort Disebut "Quick" Kalau Kasus Terburuknya Sama Jeleknya dengan Bubble Sort?

Ini pertanyaan bagus. Nama "quick" itu merujuk ke performa rata-ratanya, bukan ke kasus terburuknya. Di praktik sehari-hari, data acak jauh lebih sering muncul dibanding data yang disusun khusus buat bikin quick sort jatuh ke kasus terburuk. Ditambah lagi, dengan trik pemilihan pivot yang lebih pintar—misalnya pivot acak atau median-of-three—kemungkinan ketemu kasus terburuk itu jadi sangat kecil. Jadi meskipun secara teori kompleksitasnya bisa O(n²), secara statistik itu jarang kejadian.

Apa Bedanya Sorting In-Place dengan Sorting Biasa?

Sorting in-place berarti algoritma mengubah array asli secara langsung tanpa membuat salinan baru yang memakan memori tambahan signifikan. Bubble sort itu contoh sorting in-place yang murni, karena cuma menukar posisi elemen di array yang sama. Quick sort versi partition (yang kita bahas di Langkah 5) juga in-place, sementara versi list comprehension yang lebih gampang dibaca itu bukan in-place karena dia bikin list kiri, tengah, dan kanan yang baru di setiap pemanggilan rekursif.

Apakah Aku Wajib Paham Bubble Sort Sebelum Belajar Quick Sort?

Nggak wajib, tapi disarankan. Bubble sort itu jembatan yang bagus buat memahami konsep dasar "membandingkan lalu menukar", yang sebenarnya juga muncul di algoritma sorting lain, termasuk di bagian partitioning-nya quick sort. Kalau kamu langsung loncat ke quick sort tanpa paham konsep dasar ini, biasanya kamu bakal kesulitan waktu debugging, terutama pas nyari tahu kenapa hasil sortingnya salah.

Algoritma Sorting Mana yang Paling Cepat Secara Keseluruhan?

Nggak ada jawaban tunggal, karena itu tergantung karakteristik datanya. Untuk data acak berukuran besar, quick sort dan merge sort umumnya jadi pilihan tercepat. Untuk data yang sudah hampir terurut, insertion sort justru bisa lebih cepat dari quick sort. Untuk kebutuhan produksi sehari-hari, algoritma hybrid seperti Timsort (dipakai Python) atau Introsort (dipakai C++) biasanya jadi pilihan paling seimbang karena mereka otomatis beradaptasi dengan karakteristik data yang sedang diurutkan.

Menguji Fungsi Sorting dengan Unit Test Sederhana

Salah satu kebiasaan yang sering diabaikan waktu belajar algoritma adalah menguji kode secara sistematis. Kebanyakan orang cuma jalanin fungsi sekali, lihat hasilnya kelihatan benar, terus dianggap selesai. Padahal cara ini gampang banget kecolongan bug, apalagi kalau kamu ngetes cuma pakai satu contoh data yang "baik-baik saja".

Python punya modul bawaan namanya unittest yang bisa kamu pakai buat menguji fungsi bubble sort dan quick sort secara lebih rapi. Kalau kamu belum familier, dokumentasi resmi di docs.python.org menjelaskan modul ini dengan cukup lengkap.

Berikut contoh file pengujian sederhana:

Baca juga Codex CLI dari OpenAI: Panduan Lengkap Ngoding di Terminal

# test_sorting.py
import unittest
from sorting import bubble_sort, quick_sort

class TestSorting(unittest.TestCase):
    def test_data_acak(self):
        data = [5, 2, 9, 1, 5, 6]
        self.assertEqual(bubble_sort(data.copy()), [1, 2, 5, 5, 6, 9])
        self.assertEqual(quick_sort(data.copy()), [1, 2, 5, 5, 6, 9])

    def test_data_kosong(self):
        self.assertEqual(bubble_sort([]), [])
        self.assertEqual(quick_sort([]), [])

    def test_satu_elemen(self):
        self.assertEqual(bubble_sort([42]), [42])
        self.assertEqual(quick_sort([42]), [42])

    def test_sudah_terurut(self):
        data = [1, 2, 3, 4, 5]
        self.assertEqual(bubble_sort(data.copy()), [1, 2, 3, 4, 5])
        self.assertEqual(quick_sort(data.copy()), [1, 2, 3, 4, 5])

    def test_terurut_terbalik(self):
        data = [5, 4, 3, 2, 1]
        self.assertEqual(bubble_sort(data.copy()), [1, 2, 3, 4, 5])
        self.assertEqual(quick_sort(data.copy()), [1, 2, 3, 4, 5])

if __name__ == "__main__":
    unittest.main()

Jalankan file ini lewat terminal dengan perintah python -m unittest test_sorting.py. Kalau semua test lolos, kamu bakal lihat output kayak gini:

.....
----------------------------------------------------------------------
Ran 5 tests in 0.001s

OK

Kenapa cara ini lebih baik dibanding cuma ngeprint hasil manual? Karena begitu kamu ubah kode—misalnya waktu optimasi bubble sort atau ganti strategi pivot di quick sort—kamu tinggal jalanin ulang file test ini buat mastiin nggak ada yang rusak. Ini kebiasaan dasar yang dipakai di hampir semua tim engineering profesional, dan nggak ada ruginya kamu latih dari sekarang, sekalipun kamu baru belajar algoritma sorting.

Menangani Kasus-Kasus Ekstrem yang Sering Terlewat

Waktu ngetes fungsi sorting, ada beberapa kondisi data yang sering banget luput dari perhatian, padahal justru di situ bug paling sering ngumpet.

List Kosong

Coba jalankan bubble_sort([]) dan quick_sort([]). Kedua fungsi yang kita tulis sebelumnya seharusnya tetap mengembalikan list kosong tanpa error, karena perulangan for i in range(n - 1) di bubble sort otomatis nggak jalan kalau n adalah 0, dan base case if len(data) <= 1 di quick sort langsung menangkap kondisi ini.

List dengan Satu Elemen

Sama seperti list kosong, list dengan satu elemen itu sudah otomatis "terurut" tanpa perlu diproses apa-apa. Kalau fungsi kamu justru error di kondisi ini, biasanya masalahnya ada di logika indexing yang mengasumsikan minimal ada dua elemen.

Data dengan Banyak Duplikat

Ini kondisi yang sering bikin masalah khusus di quick sort. Coba bayangin kamu punya data [5, 5, 5, 5, 5]. Kalau kamu pakai versi in-place dengan Lomuto partition dan pivotnya elemen terakhir, performanya bisa merosot ke O(n²) karena partisi jadi sangat timpang. Versi list comprehension yang kita tulis di Langkah 4 sebenarnya lebih tahan terhadap kasus ini, karena elemen yang sama persis dengan pivot langsung dikumpulkan di variabel tengah dan nggak perlu diproses ulang secara rekursif.

Coba jalankan ini buat lihat bedanya:

data_duplikat = [7, 7, 7, 7, 7, 7, 7]
print(quick_sort(data_duplikat))
print(quick_sort_in_place(data_duplikat.copy()))

Keduanya bakal menghasilkan output yang sama, tapi kalau kamu ukur waktunya di data duplikat yang jumlahnya sangat besar, versi list comprehension biasanya lebih konsisten performanya dibanding versi in-place dengan pivot elemen terakhir.

Data dengan Nilai Negatif atau Desimal

Banyak yang mengira bubble sort dan quick sort cuma bisa dipakai buat bilangan bulat positif. Padahal keduanya bekerja normal buat angka negatif maupun desimal, karena operator perbandingan < dan > di Python otomatis menangani semua jenis angka ini. Coba saja:

data_campuran = [-5, 3.14, 0, -1.5, 8, -100]
print(quick_sort(data_campuran))

Hasilnya bakal tetap terurut dengan benar: [-100, -5, -1.5, 0, 3.14, 8].

Bubble Sort dan Quick Sort di Luar Python

Meskipun tutorial ini fokus di Python, konsep bubble sort dan quick sort itu bersifat universal. Kalau kamu kerja di lingkungan yang pakai bahasa lain, logika yang sama tetap berlaku, cuma sintaksnya yang beda.

Versi JavaScript

function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let swapped = false;
    for (let j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        swapped = true;
      }
    }
    if (!swapped) break;
  }
  return arr;
}

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  const pivot = arr[Math.floor(arr.length / 2)];
  const kiri = arr.filter((x) => x < pivot);
  const tengah = arr.filter((x) => x === pivot);
  const kanan = arr.filter((x) => x > pivot);
  return [...quickSort(kiri), ...tengah, ...quickSort(kanan)];
}

Perhatikan betapa miripnya struktur logikanya sama versi Python. Bedanya cuma di sintaks—JavaScript pakai Math.floor() buat pembagian bulat, sementara Python pakai operator //.

Versi Java

Java sedikit lebih verbose karena sifat bahasanya yang statically typed, tapi logikanya tetap sama:

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

Kalau kamu perhatikan, Java butuh variabel temp buat nukar dua nilai, beda sama Python yang bisa langsung a, b = b, a. Ini salah satu alasan kenapa banyak orang bilang Python itu lebih ringkas buat belajar algoritma—bukan berarti bahasa lain lebih buruk, cuma soal seberapa banyak boilerplate yang harus kamu tulis.

Poin pentingnya, begitu kamu paham logika di satu bahasa, memindahkan pemahaman itu ke bahasa lain jadi jauh lebih gampang. Yang perlu kamu kuasai bukan sintaksnya, tapi cara berpikir di balik algoritmanya.

Varian Lanjutan yang Perlu Kamu Tahu

Setelah kamu nguasain versi dasar bubble sort dan quick sort, ada beberapa varian yang lumayan sering disebut di dunia praktik maupun akademis. Nggak wajib kamu implementasikan semuanya, tapi penting buat tahu keberadaannya biar nggak kaget kalau ketemu istilah ini di tempat lain.

Cocktail Shaker Sort

Ini varian dari bubble sort yang jalan dua arah—dari kiri ke kanan, terus dari kanan ke kiri, bergantian terus sampai data terurut. Tujuannya buat mengatasi kelemahan bubble sort yang disebut masalah "kura-kura" (turtle), yaitu elemen kecil yang posisinya ada di ujung akhir array dan butuh banyak putaran buat sampai ke posisi seharusnya di depan. Dengan gerakan dua arah ini, elemen kecil bisa "dijemput" lebih cepat dibanding bubble sort satu arah biasa.

Randomized Quick Sort

Alih-alih selalu memilih pivot dari posisi tetap (misalnya elemen tengah atau elemen terakhir), versi ini memilih pivot secara acak di setiap pemanggilan rekursif. Manfaatnya adalah membuat kasus terburuk jadi jauh lebih sulit terjadi, karena penyerang atau kondisi data yang disengaja buat menjatuhkan performa quick sort jadi nggak bisa diprediksi lagi. Implementasinya gampang, tinggal tambahkan langkah pemilihan indeks acak sebelum proses partitioning:

import random

def partition_random(data, low, high):
    random_index = random.randint(low, high)
    data[random_index], data[high] = data[high], data[random_index]
    return partition(data, low, high)

Dual-Pivot Quick Sort

Ini varian yang dipakai di implementasi bawaan Java sejak versi 7 buat mengurutkan array tipe primitif. Alih-alih satu pivot, algoritma ini pakai dua pivot sekaligus, sehingga data dibagi jadi tiga kelompok, bukan dua. Riset menunjukkan pendekatan ini bisa lebih cepat di praktik, meskipun secara teori kompleksitas asimptotiknya tetap O(n log n) di kasus rata-rata. Kalau kamu penasaran detail teknisnya, ini topik yang cukup mendalam dan biasanya dibahas di level akademis yang lebih lanjut.

Three-Way Partitioning (Dutch National Flag)

Varian ini dirancang khusus buat mengatasi masalah data dengan banyak duplikat, seperti yang kita bahas di bagian sebelumnya. Alih-alih cuma membagi data jadi "lebih kecil" dan "lebih besar" dari pivot, three-way partitioning membagi data jadi tiga kelompok sekaligus: lebih kecil, sama dengan, dan lebih besar dari pivot. Dengan cara ini, elemen yang nilainya sama dengan pivot nggak perlu diproses ulang secara rekursif, sehingga performa di data duplikat jadi jauh lebih baik.

Baca juga CodeBuddy: Editor Kode AI untuk Coding Lebih Cepat

Tool dan Sumber Belajar Tambahan yang Layak Kamu Coba

Belajar algoritma sorting itu bakal jauh lebih nempel kalau kamu nggak cuma baca teori, tapi juga eksplorasi lewat tool visual dan sumber belajar lain. Berikut beberapa yang menurutku layak kamu coba, berdasarkan pengalaman pribadi waktu ngajarin materi ini ke beberapa teman.

VisuAlgo adalah situs visualisasi algoritma yang menurutku paling lengkap buat urusan sorting. Kamu bisa lihat animasi step-by-step bubble sort dan quick sort dengan kecepatan yang bisa diatur, plus ada mode buat bandingin beberapa algoritma sekaligus secara berdampingan. Cocok banget dipakai sambil baca kode yang sudah kita tulis di tutorial ini.

Big-O Cheat Sheet di bigocheatsheet.com berguna buat kamu yang pengin ngecek cepat kompleksitas waktu dan ruang dari berbagai algoritma sorting sekaligus, bukan cuma bubble sort dan quick sort. Aku sering buka situs ini waktu lupa detail kompleksitas algoritma tertentu, terutama pas lagi nyiapin bahan buat sesi belajar bareng.

Kursus online lokal juga sekarang makin banyak yang bahas struktur data dan algoritma dalam bahasa Indonesia, baik lewat platform berbayar maupun video gratis di YouTube. Kalau kamu lebih nyaman belajar dengan penjelasan berbahasa Indonesia, cari kanal-kanal yang fokus di computer science fundamentals—biasanya mereka juga bahas bubble sort dan quick sort sebagai materi pembuka sebelum masuk ke algoritma yang lebih kompleks kayak merge sort, heap sort, atau graph algorithms.

Buku "Introduction to Algorithms" karya Cormen, Leiserson, Rivest, dan Stein—sering disingkat CLRS—adalah rujukan paling sering dipakai di perkuliahan ilmu komputer buat pembahasan algoritma sorting secara matematis. Bukunya memang tebal dan cukup berat, tapi kalau kamu pengin paham detail bukti matematis di balik kompleksitas quick sort, buku ini jadi salah satu sumber paling kredibel yang bisa kamu rujuk.

Kenapa Aku Masih Menyarankan Belajar Ini dari Nol

Ada yang mungkin mikir, "ngapain repot nulis bubble sort dan quick sort dari nol kalau ujung-ujungnya tetap pakai sorted() bawaan Python di proyek nyata?" Pertanyaan ini wajar, dan aku sendiri pernah mikir hal yang sama waktu awal-awal belajar.

Tapi setelah beberapa tahun kerja di berbagai proyek, aku sadar nilai dari belajar ini bukan di hasil akhirnya, melainkan di proses berpikirnya. Waktu kamu nulis bubble sort dari nol, kamu belajar cara memecah masalah jadi langkah-langkah kecil yang bisa diverifikasi satu per satu. Waktu kamu nulis quick sort, kamu belajar cara berpikir rekursif dan strategi divide and conquer, yang ternyata dipakai juga di algoritma lain seperti merge sort, binary search, bahkan beberapa algoritma machine learning yang membagi dataset jadi bagian-bagian kecil buat diproses paralel.

Selain itu, pemahaman soal kompleksitas waktu dan ruang yang kamu latih lewat dua algoritma ini bakal kepake terus setiap kali kamu harus mengevaluasi trade-off antara kecepatan dan penggunaan memori di proyek nyata. Ini skill yang nggak keliatan langsung hasilnya, tapi kepake terus dalam jangka panjang, apalagi kalau karier kamu ke arah backend engineering atau data engineering yang sering banget berurusan sama data dalam jumlah besar.

Satu hal lagi yang sering luput: memahami algoritma sorting dari nol bikin kamu lebih kritis waktu milih tools atau library. Kamu jadi nggak asal pakai fungsi bawaan tanpa tahu apa yang terjadi di baliknya, dan itu bikin kamu lebih siap waktu ketemu kasus yang memang butuh implementasi custom—misalnya kalau kamu perlu sorting dengan aturan perbandingan yang sangat spesifik dan nggak bisa ditangani fungsi sorted() standar begitu saja.

Jadi kalau ada yang nanya lagi kenapa masih perlu belajar bubble sort dan quick sort padahal ada fungsi bawaan yang lebih cepat dan aman, jawabannya sederhana: kamu belajar bukan buat mengalahkan fungsi bawaan itu, tapi buat paham cara kerja yang ada di baliknya, biar keputusan teknis yang kamu ambil ke depannya lebih berdasar, bukan cuma ikut-ikutan tanpa tahu alasannya.

Menerapkan Bubble Sort dan Quick Sort ke Data yang Lebih Kompleks

Semua contoh di atas masih pakai angka polos. Tapi di dunia nyata, kamu jarang banget cuma ngurutin angka doang. Lebih sering kamu bakal ngurutin daftar objek, misalnya data pengguna, produk, atau transaksi yang punya beberapa atribut sekaligus.

Kabar baiknya, logika bubble sort dan quick sort yang udah kamu pelajari tetap bisa dipakai, cuma bagian perbandingannya yang perlu disesuaikan. Di Python, kamu bisa manfaatin fungsi atau lambda buat nentuin kriteria pembanding:

produk = [
    {"nama": "Sepatu", "harga": 250000},
    {"nama": "Tas", "harga": 180000},
    {"nama": "Jaket", "harga": 320000},
]

def bubble_sort_objek(data, key):
    n = len(data)
    for i in range(n - 1):
        swapped = False
        for j in range(n - i - 1):
            if key(data[j]) > key(data[j + 1]):
                data[j], data[j + 1] = data[j + 1], data[j]
                swapped = True
        if not swapped:
            break
    return data

hasil = bubble_sort_objek(produk, key=lambda x: x["harga"])
print(hasil)

Perhatikan parameter key di fungsi di atas. Alih-alih membandingkan data[j] langsung, kita bandingkan key(data[j]), yaitu nilai harga dari tiap produk. Pola yang sama juga bisa kamu terapin ke quick sort versi list comprehension, tinggal ganti kondisi x < pivot jadi key(x) < key(pivot).

Kalau kamu penasaran gimana Python menangani sorting berbasis key secara lebih efisien lewat fungsi bawaannya, dokumentasi di Real Python ngebahas ini dengan cukup detail, termasuk perbandingan antara sort() dan sorted() yang sering bikin bingung orang yang baru belajar.

Latihan Biar Insting Sorting Kamu Makin Kebentuk

Baca teori doang nggak bakal cukup buat bikin pemahaman ini nempel. Coba kerjain beberapa latihan berikut, tanpa lihat kode yang udah ditulis di tutorial ini:

1. Modifikasi bubble sort supaya bisa ngurutin string berdasarkan panjang karakternya, bukan berdasarkan urutan abjad.

2. Buat versi quick sort yang milih pivot secara acak, lalu bandingkan waktu eksekusinya dengan versi pivot elemen tengah pada data yang sudah terurut.

3. Gabungkan bubble sort dengan pengecekan swapped di dalam satu fungsi, terus hitung berapa kali proses swap terjadi buat data acak sejumlah 100 elemen.

4. Coba urutin list yang isinya campuran angka positif, negatif, dan nol, terus perhatiin apakah hasilnya tetap konsisten di kedua algoritma.

Kalau kamu ngerjain empat latihan ini sampai tuntas, kemungkinan besar kamu udah nggak akan bingung lagi kalau ketemu soal sorting di technical test manapun.

Soal Sorting di Wawancara Kerja Startup Lokal

Buat kamu yang lagi ngincer posisi software engineer di startup Indonesia—entah itu di Jakarta, Bandung, atau kota besar lain—soal soal seputar bubble sort dan quick sort ini hampir pasti muncul, walau kadang dibungkus dalam bentuk studi kasus, bukan pertanyaan teori mentah.

Biasanya pewawancara nggak nanya "jelasin cara kerja quick sort" secara gamblang. Mereka lebih sering ngasih skenario semacam, "gimana caranya kamu ngurutin jutaan data transaksi harian tanpa bikin server kewalahan?" Nah, di titik inilah pemahaman kamu soal kompleksitas waktu, trade-off memori, dan kapan harus pakai algoritma bawaan bahasa pemrograman jadi kelihatan jelas bedanya sama yang cuma hafal definisi.

Beberapa hal yang biasanya jadi penilaian pewawancara:

• Apakah kamu bisa menjelaskan alasan di balik pemilihan algoritma, bukan cuma menyebut namanya.

• Apakah kamu ngerti kapan sebuah algoritma bakal jatuh ke kasus terburuk.

• Apakah kamu bisa membaca kode orang lain dan nemuin bug di bagian partitioning atau pengecekan batas index.

Kalau kamu mau latihan soal-soal sejenis ini secara lebih terstruktur, situs seperti GeeksforGeeks punya kumpulan soal interview seputar sorting yang lumayan lengkap dan sering dipakai buat persiapan technical test, baik buat perusahaan lokal maupun multinasional.

Baca juga GitHub Copilot: Cara Mempercepat Kerja Tim

Membawa Pemahaman Ini ke Proyek Portofolio Kamu

Salah satu cara paling efektif buat nunjukin pemahaman kamu soal algoritma sorting bukan cuma lewat sertifikat kursus, tapi lewat proyek nyata yang bisa kamu pamerin. Kamu bisa bikin proyek kecil semacam "visualizer sorting" pakai Python dengan library seperti matplotlib atau pygame, yang nampilin animasi bubble sort dan quick sort secara berdampingan.

Proyek kayak gini punya dua manfaat sekaligus. Pertama, kamu jadi lebih paham detail algoritmanya karena harus mikirin gimana cara nge-render tiap langkah perbandingan dan swap. Kedua, proyek ini jadi bahan portofolio yang konkret waktu kamu ngelamar kerja, apalagi kalau kamu tambahin fitur perbandingan waktu eksekusi secara real-time antar algoritma.

Kesimpulan

Menguasai bubble sort dan quick sort bukan sekadar soal menghafal sintaks, tapi soal memahami kenapa satu algoritma cocok untuk situasi tertentu dan gagal total di situasi lain. Bubble sort mengajarkan kamu fondasi berpikir algoritmik lewat cara yang paling sederhana, sementara quick sort menunjukkan bagaimana strategi divide and conquer bisa mengubah cara data dalam jumlah besar diproses secara efisien. Begitu kamu paham perbedaan mendasar ini, soal-soal sorting yang dulu terasa membingungkan justru jadi kesempatan buat menunjukkan cara berpikirmu, bukan sekadar hafalan.

Empat latihan yang sudah dibahas tadi bukan pelengkap, melainkan jembatan supaya teori benar-benar menempel jadi kemampuan praktis. Begitu juga dengan simulasi wawancara kerja di startup lokal—di situlah kamu belajar bahwa jawaban ideal bukan cuma "algoritma ini lebih cepat", tapi juga mempertimbangkan ukuran data, kondisi data awal, dan batasan memori yang tersedia. Kemampuan membaca konteks seperti ini yang sering membedakan kandidat yang benar-benar paham dari yang cuma menghafal Big O.

Kalau kamu serius mau memperdalam ini, jangan berhenti di membaca artikel. Bangun sendiri proyek visualizer sorting yang sudah disinggung sebelumnya, coba variasikan datanya, lalu ukur sendiri performanya. Semakin sering tanganmu kotor dengan kode, semakin cepat pemahamanmu soal bubble sort dan quick sort berubah dari sekadar teori jadi modal nyata yang siap dipakai, baik di technical test maupun di proyek kerja sehari-hari.

Referensi

C-Sharp Corner. (2026). Understanding Sorting Algorithms: Bubble, Merge, and Quick Sort.

AskDifference. (2026). Quick Sort vs. Bubble Sort: What's the Difference.

AlgoCademy. (2026). Sorting Algorithms Explained: From Bubble Sort to Quick Sort.

LinkedIn. (2026). Sorting Algorithms Demystified: From Bubble Sort to Quick Sort.

DifferenceBetween. (2026). Difference Between Quick Sort and Bubble Sort.

VisuAlgo. (2026). Sorting Algorithms: Bubble, Selection, Insertion, Merge, Quick, Counting, and Radix Sort.

DSA Visualization. (2026). Sorting Algorithms Visualizer: Bubble, Merge, and Quick Sort.

GeeksforGeeks. (2026). Bubble Sort Algorithm.

YouTube. (2026). Algorithm Comparison: Bubble Sort vs Quick Sort.

Medium. (2026). Sorting Algorithms: From Bubble Sort to Quick Sort.