Pengenalan Desain dan Analisis Algoritma

Pengenalan Desain dan Analisis Algoritma
Sebagai salah satu dasar dari ilmu komputer, algoritma merupakan hal yang sangat penting untuk dikuasai oleh orang-orang yang berkecimpung di dunia ilmu komputer, dari peneliti sampai ke praktisi. Tentunya penguasaan akan algoritma tidak cukup hanya sampai pada tahap mengetahui dan menggunakan algoritma yang tepat untuk menyelesaikan masalah. Seorang yang mengerti ilmu komputer harus juga mampu merancang dan mengembangkan sebuah algoritma berdasarkan masalah-masalah yang ditemui. Tulisan ini bertujuan untuk memberikan pengertian mendasar mengenai perancangan (desain) dan pengembangan algoritma, agar pembaca dapat tidak hanya menggunakan algoritma yang sudah ada, tetapi juga merancang dan mengembangkan algoritma sesuai dengan masalah yang akan diselesaikan.
Selain memberikan dasar perancangan, tulisan ini juga membahas jenis-jenis algoritma yang ada, untuk kemudian melakukan analisa terhadap beberapa algoritma untuk setiap jenisnya. Analisis algoritma dilakukan dengan tujuan utama agar pembaca dapat mengambil keputusan yang tepat dalam memilih algoritma untuk solusi.
Apa itu Algoritma?
Sebelum membahas mengenai perancangan ataupun analisis algoritma, tentunya kita terlebih dahulu harus mendefinisikan arti dari "Algoritma". Apa itu algoritma?
Algoritma merupakan langkah-langkah (prosedur) yang harus dilakukan untuk menyelesaikan sebuah masalah.
Program komputer umumnya dibangun dengan menggunakan beberapa algoritma untuk menyelesaikan sebuah permasalahan. Misalnya sebuah program pencarian teks seperti grep akan memerlukan algoritma khusus untuk membaca dan menelusuri file, algoritma lain untuk mencari teks yang tepat di dalam file, dan satu algoritma lagi untuk menampilkan hasil pencarian ke pengguna.
Dalam mendefinisikan algoritma, kita harus dapat mendefinisikan tiga hal utama dengan jelas, yaitu:
Masalah, yaitu sebuah persoalan yang ingin diselesaikan oleh sebuah algoritma.
Masukan, yaitu contoh data atau keadaan yang menjadi permasalahan.
Keluaran, yaitu bentuk akhir dari data atau keadaan setelah algoritma diimplementasikan ke masukan. Keluaran merupakan hasil ideal yang diinginkan dan dianggap telah menyelesaikan masalah.
Contoh (dan Solusi) Algoritma
Contoh dari sebuah definisi algoritma yang benar adalah sebagai berikut:
Masalah
Pengurutan sekumpulan nilai yang bernilai acak.
Masukan
Serangkaian data berukuran $n$.
Keluaran
Serangkaian data berukuran $n$, dengan urutan \(a_1 \leq a_2 \leq a_3 \leq ... \leq a_{n-1} \leq a_{n}\), di mana \(a_x\) adalah data pada posisi \(x\) dalam rangkaian.
Data masukan yang diinginkan merupakan rangkaian data, tanpa memperdulikan jenis data (angka, huruf, teks, dan lainnya). Contoh dari nilai masukan adalah [2, 5, 1, 3, 4] ataupun ["Doni", "Andi", "Budi", "Clara"]. Data keluaran yang diinginkan, tentunya adalah data masukan yang telah terurut: [1, 2, 3, 4, 5] dan ["Andi", "Budi", "Clara", "Doni"].
Untuk menyelesaikan masalah yang diberikan di atas, kita dapat menggunakan algoritma insertion sort. Kode di bawah menunjukkan implementasi insertion sort pada bahasa pemrograman python:
def insertion_sort(data):
for i in range(0, len(data)):
insert_val = data[i]
hole_pos = i

while hole_pos > 0 and insert_val < data[hole_pos - 1]:
data[hole_pos] = data[hole_pos - 1]
hole_pos = hole_pos - 1

data[hole_pos] = insert_val
Implementasi insertion sort yang diberikan di atas menunjukkan bahwa pada dasarnya sebuah prosedur yang harus dijalankan untuk mengubah data masukan menjadi data keluaran, sehingga masalah dapat terselesaikan.
Algoritma yang Baik
Kita telah mengetahui dengan jelas makna dari algoritma, sehingga pertanyaan selanjutnya adalah algoritma seperti apa yang dapat dikatakan sebagai algoritma yang baik? Pada umumnya kita tidak ingin menggunakan algoritma yang salah untuk menyelesaikan masalah karena hal ini dapat menyebabkan masalah tidak diselesaikan dengan optimal, atau lebih buruknya, tidak diselesaikan sama sekali.
Sebuah algoritma yang baik memiliki sifat-sifat berikut:
Benar, di mana algoritma menyelesaikan masalah dengan tepat, sesuai dengan definisi masukan / keluaran algoritma yang diberikan.
Efisien, berarti algoritma menyelesaikan masalah tanpa memberatkan bagian lain dari apliikasi. Sebuah algoritma yang tidak efisien akan menggunakan sumber daya (memori, CPU) yang besar dan memberatkan aplikasi yang mengimplementasikan algoritma tersebut.
Mudah diimplementasikan, artinya sebuah algoritma yang baik harus dapat dimengerti dengan mudah sehingga implementasi algoritma dapat dilakukan siapapun dengan pendidikan yang tepat, dalam waktu yang masuk akal.
Pada prakteknya, tentunya ketiga hal tersebut tidak dapat selalu tercapai. Kebenaran dari sebuah algoritma umumnya selalu dapat dicapai, setidaknya untuk nilai-nilai masukan umum, tetapi efisiensi dan kemudahan implementasi tidak selalu didapatkan. Begitupun, tentunya kita harus tetap berusaha mencapai ketiga hal tersebut dalam merancang sebuah algoritma.
Pembuktian Kebenaran Algoritma
Kita telah mengetahui bahwa sebuah algoritma yang baik adalah algoritma yang benar, efisien, dan mudah diimplementasikan. Pertanyaan berikutnya tentunya adalah, bagaimana kita mengetahui bahwa sebuah algoritma telah benar? Algoritma yang efisien itu seperti apa? Bagaimana kita mengukur kemudahan implementasi sebuah algoritma?
Bagian ini akan membahas mengenai pertanyaan pertama, yaitu bagaimana kita dapat mengetahui kebenaran sebuah algoritma. Tentunya efisiensi dan kemudahan implementasi sebuah algoritma menjadi tidak penting jika algoritma tersebut tidak dapat memberikan hasil yang benar.
Definisi dari kebenaran algoritma yang digunakan pada tulisan ini adalah sebagai berikut:
Sebuah algoritma dikatakan telah benar jika algoritma tersebut dapat memberikan keluaran yang benar jika menerima masukan sesuai dengan definisi algoritma tersebut, dan algoritma tersebut terbukti akan selalu dapat diterminasi (berakhir).
Pembuktian kebenaran sebuah algoritma sendiri dapat dilakukan dengan beberapa cara, misalnya:
Induksi Matematika,
Pembuktian kontradiktif,
Pembuktian kontrapositif, dan
Metode Formal.
Masing-masing alat pembuktian yang disebutkan memiliki kelebihan dan kekurangan masing-masing, serta kasus pengunaan yang berbeda-beda. Perlu diingat juga bahwa masih terdapat sangat banyak alat-alat pembuktikan lainnya yang dapat digunakan, tetapi kita hanya membahas satu cara pembuktian (induksi matematika) saja sebagai pengenalan cara membuktikan algoritma. Jika dibutuhkan, metode dan alat pembuktian lain akan dijelaskan lagi pada bagian yang relevan.
Sekarang mari kita lihat penggunaan masing-masing alat tersebut untuk membuktikan algoritma!
Induksi Matematika
Induksi matematika merupakan alat pembuktian matematis yang digunakan untuk membuktikan pernyataan atau proses yang melibatkan perhitungan bilangan asli yang berulang. Contoh dari rumus matematis yang dapat dibuktikan dengan menggunakan induksi matematika yaitu perhitungan deret aritmatika, deret geometris, ataupun sigma bilangan.
Pembuktian menggunakan induksi matematika dilakukan dengan dua langkah, yaitu:
Melakukan pembuktian kasus dasar (base case), yaitu membuktikan bahwa sebuah pernyataan (fungsi) matematika atau algoritma bernilai benar jika diaplikasikan pada bilangan pertama yang sah sesuai dengan spesifikasi fungsi atau algoritma tersebut.
Melakukan induksi, yaitu membuktikan bahwa kebenaran dari fungsi \(P(k+1)\) jika kebenaran fungsi \(P(k)\) diketahui.
Dengan membuktikan kedua hal tersebut, kita dapat mengambil kesimpulan bahwa sebuah fungsi matematika atau algoritma bernilai benar untuk semua bilangan asli. Jika diimplementasikan dengan tepat, induksi matematika dapat juga digunakan untuk membuktikan kebenaran algoritma rekursif seperti penelusuran pohon (tree).
Untuk lebih jelasnya, mari kita lihat beberapa contoh cara pembuktian yang dilakukan dengan menggunakan induksi matematika.
Contoh 1: Deret Aritmatika
Misalkan kita diminta untuk membuktikan bahwa pernyataan matematika untuk perhitungan deret aritmatika berikut:
\[1 + 2 + 3 + ... + n = \frac{n(n + 1)}{2}\]
adalah benar untuk semua bilangan bulat \(n \geq 1\).
Untuk membuktikan pernyataan matematika di atas, terlebih dahulu kita harus mengubah pernyataan matematika tersebut menjadi sebuah fungsi matematika:
\[P(k) = 1 + 2 + 3 + ... + n = \frac{k(k + 1)}{2}\]
dan kemudian membuktikan kebenarannya menggunakan induksi matematika. Seperti yang telah dijelaskan sebelumnya, kita harus menjalankan dua langkah untuk melakukan pembuktian dengan induksi:
Pembuktian Kasus Dasar
Karena pernyataan matematika pada soal menyatakan bahwa pernyataan benar untuk semua bilangan bulat \(k \geq 1\), maka untuk pembuktian kasus dasar kita harus membuktikan bahwa \(P(1)\) adalah benar untuk ruas kiri maupun ruas kanan dari \(P(k)\).
\[\begin{split}P(1)= 1 & = \frac{1(1+1)}{2} \\ 1 & = \frac{1(2)}{2} \\ 1 & = \frac{2}{2} \\ 1 & = 1\end{split}\]
karena hasil akhir dari ruas kanan dan ruas kiri adalah sama (\(1\)), maka dapat dikatakan bahwa kasus dasar telah terbukti.
Induksi
Untuk pembuktian induksi, kita harus membuktikan bahwa \(P(k) \rightarrow P(k + 1)\) bernilai benar.
Langkah pertama yang dapat kita lakukan yaitu menuliskan fungsi matematis dari \(P(k + 1)\) terlebih dahulu:
\[P(k + 1) = 1 + 2 + ... + k + (k + 1) = \frac{(k + 1)((k + 1) + 1)}{2}\]
dan kemudian kita harus membuktikan bahwa ruas kiri dan ruas kanan dari \(P(k + 1)\) adalah sama. Pembuktian akan kita lakukan dengan melakukan penurunan pada ruas kiri agar menjadi sama dengan ruas kanan:
\[\begin{split}1 + 2 + ... + k + (k + 1) & = (1 + 2 + ... + k) + (k + 1) \\ & = \frac{k(k + 1)}{2} + (k + 1) \\ & = \frac{k(k + 1) + 2(k + 1)}{2} \\ & = \frac{k^2 + 3k + 2}{2} \\ & = \frac{(k + 1)(k + 2)}{2} \\ & = \frac{(k + 1)((k + 1) + 2)}{2}\end{split}\]
dan seperti yang dapat dilihat, ruas kiri dari \(P(k + 1)\) telah menjadi sama dengan ruas kanannya, sehingga dapat dikatakan bahwa tahap induksi telah berhasil dibuktikan benar.
Dengan pembuktian kasus dasar dan induksi yang bernilai benar, kita dapat menyimpulkan bahwa \(P(n)\) bernilai benar untuk \(n \geq 1\).
Contoh 2: Pembuktian Hipotesa
Anda diminta untuk membuktikan hipotesa bahwa fungsi matematika \(n^3-n\) habis dibagi 6 untuk semua bilangan bulat \(n \geq 2\).
Langkah untuk membuktikan pernyataan tersebut sama dengan sebelumnya. Mulai dari definisi ulang fungsi matematikanya:
\[P(k) = k^3 - k\]
Dan kemudian lakukan induksi matematika, langkah demi langkah:
Pembuktian Kasus Dasar
Lakukan perhitungan \(P(2)\) (karena nilai \(k\) minimal 2) dan pastikan hasilnya habis dibagi 6:
\[\begin{split}P(1) & = 2^3 - 2 \\ & = 8 - 2 \\ & = 6\end{split}\]
karena \(6 \bmod 6 = 0\) maka telah dapat dibuktikan bahwa kasus dasar bernilai benar.
Induksi
Jika \(P(k)\) benar habis dibagi 6, maka \(P(k + 1)\), atau \((k + 1)^3 - (k + 1)\) harus juga habis dibagi 6. Mari kita lakukan pembuktiannya:
\[\begin{split}P(k + 1) & = (k + 1)^3 - (k + 1) \\ & = (k^3 + 3k^2 + 3k + 1) - k - 1 \\ & = k^3 - 3k^2 + 2k \\ & = k^3 - 3k^2 + 2k + k - k \\ & = k^3 - 3k^2 + 3k - k \\ & = k^3 - k + 3k^2 + 3k \\ & = (k^3 - k) + 3k(k + 1)\end{split}\]
dan dapat dilihat bagaimana \(P(k + 1)\) telah terbukti habis dibagi 6 karena:
\(k^3 - k\) habis dibagi 6, sesuai dengan hipotesa \(P(k)\), dan
\(3k(k + 1)\) habis dibagi 6 karena salah satu nikai dari \(k\) atau \(k + 1\) pasti merupakan bilangan genap, yang jika dikalikan dengan 3 akan habis dibagi 6.
Setelah berhasil menyelesaikan dua langkah induksi, kita dapat menyimpulkan bahwa \(P(k) = k^3 - k\) habis dibagi 6 untuk \(k \geq 2\).
Induksi Matematika untuk Pembuktian Algoritma
Seperti yang dapat dilihat dari apa yang telah kita pelajari pada bagian sebelumnya, induksi matematika jelas sangat berguna untuk membuktikan kebenaran sebuah teorema atau fungsi yang melibatkan perhitungan bilangan bulat yang berulang. Tetapi apa guna induksi matematika untuk membuktikan kebenaran sebuah algoritma?
Sebuah algoritma kerap kali akan memiliki bagian yang melakukan perhitungan bilangan atau data secara berulang. Kita dapat menggunakan konsep perulangan pada pemrograman untuk menerapkan perhitungan bilangan ataupun data secara berulang. Misalnya, algoritma berikut menghitung hasil kali dari dua buah bilangan bulat:
def kali(m, n):
if m < 0:
return -1 # error
else:
i = 0
result = 0

while(m != i):
result = result + n
i = i + 1

return result
yang secara matematis dapat dituliskan sebagai fungsi berikut:
\[f(m, n) = \sum_{i=1}^{n} m; n \geq 0\]
atau lebih sederhananya:
\[m \times n = \underbrace{m + m + m + ... + m}_{\text{n kali}}\]
dan secara otomatis tentunya pernyataan matematis tersebut dapat kita buktikan dengan menggunakan induksi matematika. Pembuktian perulangan yang lebih kompleks sendiri dapat dilakukan dengan teknik yang dikenal dengan nama loop invariant, yang tidak akan dijelaskan pada tulisan ini.
Pemodelan Masalah
Pada bagian sebelumnya kita telah melihat bagaimana sebuah algoritma dituliskan menjadi fungsi matematika. Baik algoritma maupun fungsi matematika adalah sebuah model, yang digunakan untuk menggambarkan masalah yang ditemui pada dunia nyata, dan ingin diselesaikan, baik dengan menggunakan matematika ataupun program komputer. Dengan memiliki model masalah kita dapat lebih mudah mengerti masalah yang akan diselesaikan, yang akan menyebabkan solusi yang ditawarkan menjadi lebih baik.
Tetapi pertanyaannya tentunya adalah, bagaimana kita membuat model yang benar dari masalah-masalah yang ada? Bagian ini akan menjelaskan mengenai cara pembangunan model, baik secara matematis maupun algoritmik, yang benar.
Jenis-Jenis Model
Sebelum mulai membangun model permasalahan, tentunya kita terlebih dahulu harus mengetahui jenis-jenis model yang ada. Terdapat enam jenis model yang umum digunakan untuk menggambarkan masalah dalam dunia algoritma / pemrograman, yaitu:
Model Numerik
Model numerik merupakan model matematis yang paling sederhana, yang dibuat untuk mendeskripsikan jumlah atau ukuran dari sesuatu. Model numerik menggunakan angka (1, 2, 3, dst) untuk mendeskripsikan suatu hal. Misalkan gambar di bawah:

Model Numerik Sapi
memberikan informasi sejumlah sapi yang ada di dalam kotak. Model numerik paling sederhana dan informatif yang dapat kita ambil dari gambar tersebut adalah 'Lima ekor Sapi' atau 'Lima Sapi'.
Model Simbolik
Jika kita mengembangkan model numerik lebih jauh, kita kemudian dapat menambahkan simbol-simbol baru untuk melakukan pemrosesan terhadap angka-angka yang ada pada model numerik. Terdapat empat buah simbol dasar untuk pemrosesan angka, yaitu \(+, -, \times, \text{dan} \div\). Simbol \(=\) juga digunakan untuk menandakan kesamaan nilai antara ruas kiri dan ruas kanan dari \(=\).
Note
Simbol \(\times \text{dan} \div\) akan dituliskan sebagai \(*\) dan \(/\) pada tulisan ini, karena kedua simbol tersebut lebih umum digunakan pada lingkungan ilmu komputer.
Jadi, sebuah ekspresi matematika seperti ini:
\[10 = 5 * 2\]
dapat dikatakan adalah sebuah model simbolik. Tentunya operator-operator numerik yang disebutkan sebelumnya memiliki aturan tertentu untuk beropearsi. Aturan-aturan umum yang kita temui untuk operator numerik yaitu:
Hukum Kumulatif, di mana \(a + b = b + a\) dan \(a * b = b * a\).
Hukum Asosiatif, di mana \(a + (b + c) = (a + b) + c\) dan \(a * (b * c) = (a * b) * c\).
Hukum Distribusi, di mana \(a * (b + c) = (a * b) + (a * c)\).
Hukum Invers, yaitu \(a + (-a) = 0\) dan a * frac{1}{a} = 1.
Hukum Identitas, yaitu \(a + 0 = a$ dan $a * 1 = a\).
Perkalian dengan 0, yaitu \(a * 0 = 0\).
Penjelasan mengenai kegunaan dan cara kerja dari hukum-hukum tersebut tidak akan dibahas lagi, karena dianggap telah diketahui oleh pembaca. Yang perlu diperhatikan adalah bagaimana kita menuliskan simbol-simbol seperti $a$ dan $b$, untuk melambangkan semua bilangan-bilangan yang mengikuti hukum-hukum di atas. Simbol-simbol yang dapat melambangkan bilangan atau nilai lain secara generik seperti ini dikenal dengan nama variabel.
Sebuah variabel merupakan simbol yang digunakan untuk merepresentasikan nilai yang dapat berubah kapanpun, tergantung dari nilai yang kita berikan kepada variabel tersebut. Variabel digunakan dalam model simbolik untuk mewakili nilai-nilai yang dapat berubah sewaktu-waktu, misalnya nilai yang harus dibaca dari masukan pengguna atau nilai yang diambil secara acak. Sebuah model bahkan dapat terdiri dari hanya variabel saja, misalnya model matematika untuk menghitung luas sebuah persegi panjang dapat dituliskan seperti berikut:
\[L = p * l\]
di mana \(p\) dan \(l\) mewakili panjang dan lebar persegi panjang, yang nilainya selalu berbeda-beda, tergantung dengan persegi panjang yang akan dihitung luasnya. Nilai \(L\), yang merepersentasikan luas persegi panjang, sendiri bergantung kepada nilai \(p\) dan \(l\), sehingga kita tidak akan mendapatkan nilai \(L\) yang konstan.
Deklarasi variabel sendiri dilakukan dengan menggunakan perintah $let$, seperti berikut:
\[\text{let }L = \text{Luas Persegi}\]
Selain model-model dengan variabel, tentunya kita juga memiliki model-model yang memiliki bilangan konstan yang tidak berubah, misalnya untuk menghitung luas segitiga:
\[L = \frac{1}{2} * a * t\]
atau model untuk menghitung keliling lingkaran:
\[K = 2 * \pi * r\]
Nilai-nilai yang tidak pernah berubah pada kedua model di atas (seperti \(2\), \(\frac{1}{2}\), dan \(\pi\)) dikenal dengan nama konstanta. Perhatikan bahwa konstanta dapat mencakup angka "mentah" seperti \(2\) ataupun simbol yang dikenal secara luas seperti \(\pi\). Konstanta biasanya dideklarasikan pada awal model atau kamus data program, dan tidak pernah berubah nilainya selama model tersebut digunakan.
Dari berbagai komponen dan contoh model simbolik yang telah kita lihat, dapat disimpulkan bahwa model simbolik merupakan model yang menggambarkan interaksi dan operasi antar komponen numerik secara abstrak. Abstraksi dari komponen numerik (angka) pada model simbolik dilakukan dengan menggunakan variabel dan konstanta.
Model Spasial
Tidak semua permasalahan yang diselesaikan oleh matematika atau komputer selalu berhubungan langsung dengan angka. Terkadang kita menjumpai juga masalah-masalah yang berhubungan dengan representasi dunia nyata seperti perhitungan jarak dua objek atau pencarian jalur terdekat untuk kendaraan. Secara tradisional, model untuk penyelesaian masalah seperti ini digambarkan dengan peta, graph, dan gambar-gambar teknis lainnya.
Untuk dunia komputer, model-model dunia nyata biasanya digambarkan dengan menggunakan koordinat. Sistem koordinat yang paling populer digunakan dalam hal ini adalah koordinat kartesius. Koordinat kartesius merupakan sistem koordinat yang menggambarkan sebuah nilai riil di dalam kumpulan nilai yang direpresentasikan dengan sebuah garis. Sistem kartesius dapat digambarkan dalam banyak dimensi, sesuai dengan jumlah kumpulan nilai yang digambarkan. Untuk memudahkan pengertian, gambar di bawah memperlihatkan contoh sistem koordinat kartesius dua dimensi:

Sistem Koordinat Kartesius
Untuk menyederhanakan masalah, mayoritas algoritma dan solusi yang dikembangkan dalam kuliah ini akan dilakukan dengan menggunakan sistem kartesius dua dimensi. Sistem tiga dimensi dan satu dimensi dianggap dapat diimplementasikan menggunakan konsep yang sama dengan sistem dua dimensi.
Data pada sistem kartesius dua dimensi dapat direpresentasikan dalam bentuk sebuah titik, yaitu kombinasi antara sumbu x dan sumbu y:

Titik pada Kartesius
atau sebuah garis, yang direpresentasikan dengan sebuah fungsi matematika:

Garis pada Kartesius
Dalam prakteknya, kita juga akan sering memerlukan informasi arah pergerakan dari sebuah garis. Untuk merepresentasikan hal tersebut, kita dapat menambahkan sebuah tanda panah pada garis:

Garis Berarah pada Kartesius
dan yang terakhir, kita dapat juga merepresentasikan sebuah bentuk atau bidang, menggunakan kombinasi beberapa garis:

Bidang pada Kartesius
Untuk melakukan pemrosesan data-data yang ada di dalam sistem kartesius, kita dapat melakukan operasi terhadap titik-titik yang merepresentasikan data tersebut. Titik-titik direpresentasikan dalam bentuk matriks atau array. Misalnya, segitiga yang ada pada gambar di atas dapat direperesentasikan sebagai matriks berikut:
\[\begin{split}\begin{bmatrix} -3 & 4 & 1 \\ 1 & 3 & -2 \end{bmatrix}\end{split}\]
Dan kemudian tentunya kita dapat melakukan operasi-operasi matriks untuk melakukan berbagai hal terhadap segitiga tersebut.
Model Logis
Model logis merupakan cara memodelkan masalah berdasarkan logika matematika. Terdapat empat cabang utama dari logika matematika, yaitu teori himpunan, teori model, teori rekursif, dan teori pembuktian. Masing-masing teori memiliki cara pemodelan yang berbeda-beda, untuk merepresentasikan masalah yang berbeda. Tulisan ini hanya akan membahas pemodelan logis pada bidang himpunan, dan relevansinya dengan salah satu sistem yang paling populer di dunia komputer: basis data.
Himpunan, seperti namanya, memodelkan sekumpulan entitas yang memiliki atribut (ciri khas) tertentu. Dalam menentukan atribut tujuan dari pengunaan himpunan lebih penting daripada kesamaan ciri khas dari entitas, sehingga terkadang atribut dari elemen-elemen dalam himpunan tidak selalu dapat dilihat dengan mudah. Misalnya, kita dapat mendeklarasikan sebuah himpunan dengan nama "Himpunan Barang dalam Handbag" dengan isi berupa "handphone, gunting kuku, alat make-up, tissue, dompet, alat tulis, dan karet gelang". Secara sekilas semua entitas yang ada di dalam himpunan tidak terlihat memiliki atribut yang jelas, meskipun himpunan ini adalah himpunan yang valid.
Terdapat dua aturan khusus yang harus dipenuhi oleh sebuah himpunan, yaitu:
Himpunan harus didefinisikan dengan tepat. Sebuah entitas yang ada di dunia hanya dapat memiliki dua status berkaitan dengan himpunan yang didefinisikan: TERMASUK dalam himpunan atau TIDAK TERMASUK. Tidak boleh ada elemen yang bersifat ambigu, dalam arti tidak jelas masuk ke dalam himpunan atau tidak. Misalnya, kita tidak dapat mendefinisikan sebuah himpunan yang berisi "Orang Tinggi" karena tidak terdapat definisi dari "tinggi" yang jelas. Apakah 170 cm termasuk tinggi? 180?
Yang dapat kita definisikan ialah himpunan yang berisi "Orang dengan tinggi badan di atas 175 cm", sehingga tidak terdapat perdebatan mengenai apakah 170 cm termasuk tinggi atau tidak.
Setiap elemen dalam himpunan harus unik. Sebuah himpunan tidak boleh memiliki nilai ganda. Aturan ini menyebabkan banyak himpunan yang ada di dunia nyata tidak dapat direpresentasikan dengan himpunan matematika. Misalnya, kita dapat saja memiliki himpunan sendok yang terdiri dari banyak sendok identik. Dalam himpunan matematis, hal ini tidak diperbolehkan. Aturan ini juga menyebabkan penggabungan himpunan menjadi sedikit berbeda. Himpunan berisi angka 1, 2, 3, 4 jika digabungkan dengan himpunan 3, 4, 5, 6 akan menghasilkan himpunan 1, 2, 3, 4, 5, 6. Ide "nilai unik" untuk setiap elemen dalam himpunan ini lah yang menjadi dasar dari pengindeksan dan primary key dari basis data relasional.
Pemodelan himpunan sendiri biasanya dilakukan dengan menggunakan diagram Venn. Gambar di bawah memberikan contoh sebuah diagram Venn, yang menggambarkan himpunan dari segi empat:

Contoh Diagram Venn
Dari gambar diagram Venn di atas, kita dapat melihat bagaimana seluruh persegi adalah juga persegi panjang, dan baik persegi maupun persegi panjang adalah merupakan segi empat. Jika kita menambahkan jenis segi empat lainnya, misalnya trapesium, dapatkah anda menggambarkan diagram Venn-nya?
Model Statistik
Terdapat banyak permasalahan di dunia nyata yang tidak dapat dimodelkan dengan mudah menggunakan keempat model matematis yang telah kita bahas sebelumnya. Terkadang kita dihadapkan dengan permasalahan yang sangat kompleks, sampai-sampai memodelkan dan menganalisa setiap situasi yang mempengaruhi masalah tersebut akan menjadi sangat mahal, memerlukan banyak orang, dan banyak waktu.
Sebagai contoh, bayangkan jika kita diminta untuk melakukan prakiraan cuaca. Dengan menggunakan model matematis yang ada, kita akan memerlukan sangat banyak kalkulasi, yang saling mempengaruhi satu sama lainnya. Praktisnya, kita harus mampu melakukan simulasi terhadap seluruh elemen yang ada di bumi untuk melakukan prakiraan cuaca dengan tepat. Hal ini tentunya sangat tidak efektif untuk dilakukan. Lalu bagaimana para ahli sekarang melakukan prakiraan cuaca?
Jawabannya adalah model statistik. Dengan mengumpulkan sampel data cuaca pada masa lalu, kita dapat melihat kecenderungan atau tren cuaca yang akan terjadi sesuai dengan keadaan cuaca kita sekarang. Pada dasarnya, sebuah model statistik melakukan analisa tren terhadap sampel data yang relevan untuk meniadakan ketidak pastian atau keadaan khusus. Dengan mengambil keadaan rata-rata dari sekumpulan data, kita akan mendapatkan kecenderungan dari sebuah keadaan jika dihadapkan dengan keadaan umumnya.

Contoh Model Statistik
Gambar di atas menunjukkan contoh dari model statistik. Ingat, bahwa kesimpulan yang dapat diambil dari sebuah model statistik hanyalah berupa kecenderungan atau tren. Kita tidak bisa membuktikan sesuatu atau memberikan hasil yang pasti menggunakan statistik. Dapat dikatakan bahwa kalimat seperti "statistik membuktikan ..." pada tulisan ilmiah populer kurang tepat.
Pseudocode
Semua model matematis yang telah dijelaskan sebelumnya merupakan model matematika yang digunakan dan dimengerti oleh manusia. Jika ingin menggunakan model matematis tersebut di komputer, terlebih dahulu kita harus melakukan konversi menjadi kode program yang dapat dibaca dan dimengerti oleh komputer. Kode program sendiri dimodelkan dengan banyak cara, dan yang paling relevan dengan algoritma ialah pseudocode.
Pseudocode memberikan langkah-langkah penyelesaian masalah dengan menggunakan bahasa manusia, dengan sedikit batasan sesuai dengan konstruk logika komputer. Pseudocode tidak memiliki konstruk untuk bahasa pemrograman tertentu, sehingga pseudocode harus bisa diimplementasikan dengan bahasa pemrograman apapun. Berikut adalah contoh pseudocode sederhana:
for i = 1 to 5 do
print i
end for
Untuk penjelasan lebih mendetail tentang pseudocode, silahkan baca kembali bahan kuliah untuk Pemrograman Dasar.
Kita telah melihat model matematis yang umum digunakan untuk menyelesaikan masalah. Pertanyaan selanjutnya tentunya adalah: kapan kita menggunakan model A dan kapan menggunakan model B? Bagaimana membuat model A menjadi kode program yang dapat dijalankan oleh komputer?
Pengembangan Model
Proses pengembangan model dapat dilakukan dengan beberapa langkah yang telah dibangun oleh para ahli matematika. Jika proses pengembangan model dilakukan mengikuti langkah-langkah yang ada, idealnya kita akan mendapatkan model yang tepat untuk permasalahan yang akan diselesaikan. Adapun langkah-langkah yang harus diambil untuk membangun sebuah model yaitu:
Apakah masalah yang dihadapi merupakan masalah yang memerlukan solusi matematis? Jika masalahnya merupakan masalah numerik (perhitungan angka) atau logis, maka jawabannya sudah pasti "ya". Jika solusi dari masalah berupa pendapat, maka kemungkinan jawabannya adalah "tidak".
Fakta-fakta relevan apa saja yang diketahui? Masalah umum yang dihadapi saat akan membangun solusi adalah informasi yang terlalu banyak, yang terkadang mencuri fokus kita dari akar masalah. Pisahkan antara fakta (informasi) yang relevan dari keseluruhan informasi yang didapatkan.
Fakta atau informasi tambahan apa yang kita perlukan untuk menyelesaikan masalah? Di mana atau bagaimana cara agar kita mendapatkan fakta-fakta tersebut?
Adakah langkah atau metode alami untuk menyelesaikan masalahnya? Metode alami artinya metode yang umumnya digunakan oleh manusia. Misalnya, untuk menghitung total dari sekumpulan nilai kita dapat menambahkan seluruh bilangan yang ada di dalam kumpulan nilai tersebut.
Apakah fakta-fakta yang ada dapat direpresentasikan oleh simbol matematis dan dikategorikan menjadi fakta yang "diketahui" dan "tidak diketahui"?
Apakah terdapat model lama yang dapat digunakan atau disesuaikan untuk menyelesaikan masalah kita?
Jika terdapat model yang telah dikembangkan sebelumnya untuk masalah kita, apakah model tersebut dapat diaplikasikan pada komputer?
Bagaimana kita dapat mengaplikasikan model dari solusi kita sehingga model tersebut dapat dibuat menjadi program komputer dengan mudah?
Dengan menjalankan langkah-langkah di atas, idealnya kita akan mendapatkan sebuah model solusi yang tepat untuk permasalahan kita. Untuk lebih jelasnya, mari kita aplikasikan model masalah yang ada ke contoh sebuah kasus!
Contoh: Perhitungan Bunga Pinjaman
Kita diminta untuk mengembangkan sebuah program komputer untuk sebuah perusahaan kredit ACME. Program yang akan kita kembangkan merupakan sistem untuk menghitung total jumlah yang harus dibayar oleh peminjam uang per tahunnya. Bunga pinjaman yang diberikan ACME adalah sebesar 15% per tahunnya.
Untuk membangun sistem perhitungan yang diminta, tentunya terlebih dahulu kita harus membangun modal solusi untuk perhitungan bunganya. Mari kita ikuti langkah-langkah untuk membangun model yang telah dijelaskan sebelumnya:
Apakah masalah yang dihadapi merupakan masalah yang memerlukan solusi matematis?
Ya. Perhitungan total bunga bunga jelas akan melibatkan matematika.
Fakta-fakta relevan apa saja yang diketahui?
Bunga pinjaman sebesar 15% per tahun.
Fakta atau informasi tambahan apa yang kita perlukan untuk menyelesaikan masalah?
Beberapa fakta tambahan yang harus ada tetapi tidak disebutkan secara eksplisit pada deskripsi masalah:
Jumlah pinjaman awal. Untuk menghitung total pinjaman dengan bunganya jelas kita harus mengetahui jumlah pinjaman awal terlebih dahulu.
Lama pinjaman. Tanpa adanya lama pinjaman, kita tidak dapat mengetahui dengan pasti total bunga yang harus ditambahkan.
Adakah langkah atau metode alami untuk menyelesaikan masalahnya?
Ya, lakukan perhitungan bunga tiap tahunnya, dan tambahkan hasil kalkulasi tersebut sampai tahun pinjaman terakhir.
Apakah fakta-fakta yang ada dapat direpresentasikan oleh simbol matematis?
Dari fakta-fakta yang kita dapatkan pada langkah kedua dan ketiga, kita dapat mendefinisikan simbol matematis seperti berikut:
\[\begin{split}\text{let }b & = \text{bunga} \\ \text{let }p & = \text{jumlah pinjaman} \\ \text{let }t & = \text{waktu pinjaman (per tahun)} \\ \text{let }T & = \text{total pinjaman}\end{split}\]
Apakah terdapat model lama yang dapat digunakan untuk menyelesaikan masalah kita?
Ya, perhitungan bunga majemuk yang dimodelkan dengan rumus: \(T = p(1 + b)^t\).
Apakah model yang ada sebelumnya pada langkah 6 dapat diaplikasikan pada komputer?
Kemungkinan tidak, karena perhitungan bunga majemuk merupakan perhitungan yang tidak banyak diketahui orang (terutama pada bidang pemrograman), dan juga memiliki banyak aturan kompleks yang harus dimengerti terlebih dahulu.
Karena kasus yang sederhana, kita akan lebih mudah mengimplementasikan algoritma kita sendiri, yang cukup melakukan iterasi dan menambahkan total pinjaman setiap tahunnya. Mari kita coba kembangkan model iterasi yang dapat digunakan.
Untuk tahun pertama, peminjam akan berhutang sebanyak:
\[T = p + (15\% * p)\]
selanjutnya, untuk tahun kedua hutangnya akan bertambah menjadi:
\[T' = T + (15\% * T)\]
di mana \(T'\) adalah nilai baru dari \(T\). Kita cukup melakukan perhitungan yang sama terus menerus, sebanyak $t$ kali untuk mendapatkan hasil akhir berupa \(T\) yang menyimpan total hutang yang dipinjam. Jika dikembangkan, maka model matematis akhir yang kita dapatkan adalah:
\[T = T + (\frac{15}{100} * T)\]
yang akan dijalankan sebanyak $t$ kali, dengan nilai $T$ yang bertambah setiap iterasinya. Dengan informasi ini, kita dapat mengimplementasikan pseudocode seperti berikut:
b = 15
T = 0

READ p, t

T = p

for i = 1 to t do
T = T + (15 / 100 * T)
end for

WRITE T
yang kemudian akan kita implementasikan sebagai fungsi penghitung total pinjaman.
Bagaimana kita dapat mengaplikasikan model dari solusi kita sehingga model tersebut dapat dibuat menjadi program komputer dengan mudah?
Pseudocode yang ada sudah sangat jelas, dan baris per barisnya dapat diimplementasikan secara langsung menggunakan bahasa pemrograman apapun.
Setelah mendapatkan model penyelesaian masalah sampai pada pseudocode-nya, kita kemudian dapat mengimplementasikan solusi yang dikembangkan menggunakan bahasa pemrograman yang diinginkan. Berikut adalah contoh implementasi algoritma tersebut pada python:
b = 15
T = 0
p = input("Masukkan jumlah pinjaman: ")
t = input("Masukkan lama pinjaman: ")

T = int(p)

for i in range(1, int(t)):
T = T + (15 / 100 * T)

print("Total pinjaman yang harus dibayarkan adalah: " + str(T))
Kesimpulan
Pada bagian ini kita telah mempelajari tentang ciri khas algoritma yang baik, yaitu benar, efisien, dan mudah diimplementasikan. Kita juga mempelajari bagaimana membuktikan sebuah algoritma adalah sebuah algoritma yang benar, dan bagaimana mengembangkan algoritma yang benar, menggunakan model matematis.
Terdapat enam jenis model matematis yang kita bahas, beserta dengan cara menggunakan model matematis tersebut ke kasus pada dunia nyata. Selanjutnya kita akan mempelajari bagaimana mengembangkan algoritma yang efisien, beserta definisi dari efisiensi algoritma tentunya.
Kompleksitas Algoritma
Pada bagian sebelumnya kita telah mempelajari mengenai algoritma yang baik, serta bagaimana membuktikan sebuah algoritma akan memberikan hasil yang benar. Selain memberikan hasil yang benar, efisiensi dari waktu eksekusi ataupun penggunaan memori dari algoritma adalah hal yang penting bagi sebuah algoritma. Bagian ini akan membahas bagaimana mengukur efisiensi sebuah algoritma, sehingga kita dapat memilih algoritma yang baik atau memperbaiki algoritma yang ada.
Langsung saja, kita mulai dengan sebuah contoh algoritma untuk menghitung perpangkatan dua bilangan. Hasil akhir dari kode yang akan dikembangkan direpresentasikan oleh fungsi matematis berikut:
\[f(x, y) = x^y\]
Salah satu implementasi sederhana untuk fungsi matematis di atas adalah:
def pangkat(x, y):
hasil = 1
for i in range(0, y):
hasil = x * hasil
return hasil
Pada dasarnya yang kita lakukan pada kode di atas ialah mengkalikan x dengan dirinya sendiri sebanyak y kali, dan menyimpan hasil kali tersebut di dalam variabel hasil. Baris hasil = x * hasil melakukan perkalian x dengan dirinya sendiri, dan perulangan dilakukan untuk memastikan baris ini dijalankan sebanyak y kali.
Dengan asumsi bahwa algoritma perpangkatan yang kita tuliskan di atas sudah benar, pertanyaan selanjutnya tentunya adalah: seberapa efisien kah algoritma tersebut?
Terdapat banyak cara untuk mengukur efisiensi sebuah algoritma, tentunya dengan kelebihan dan kekurangan dari masing-masing cara tersebut. Mari kita lihat cara mengukur efisiensi yang paling sederhana terlebih dahulu: melihat berapa langkah yang perlu dijalankan untuk menyelesaikan algoritma tersebut. Jika kita memanggil fungsi pangkat seperti berikut:
pangkat(2, 1)
Maka kode akan dieksekusi seperti berikut:
hasil = 1
for i in range(0, 1):
hasil = 2 * hasil
return hasil
yang kita perulangan for yang ada kita kembangkan akan menjadi:
hasil = 1
hasil = 2 * hasil
return hasil
Total terdapat tiga langkah yang perlu dijalankan untuk mendapatkan hasil pangkat yang diinginkan. Sangat sederhana dan mudah. Bagaimana jika kita naikkan nilai dari y sehingga kita memanggil pangkat(2, 2)?
Kode yang dieksekusi akan menjadi:
hasil = 1
for i in range(0, 2):
hasil = 2 * hasil
return hasil
yang ketika diuraikan menjadi:
hasil = 1
hasil = 2 * hasil
hasil = 2 * hasil
return hasil
dengan total 4 langkah eksekusi. Perhatikan bagaimana akibat dari meningkatkan nilai y, jumlah eksekusi dari kode di dalam loop meningkat. Berdasarkan apa yang kita dapatkan sejauh ini, kita dapat menyimpulkan bahwa jika dilakukan pemanggilan pangkat(2, 5) maka kita akan mendapatkan hasil eksekusi:
hasil = 1
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
hasil = 2 * hasil
return hasil
dan seterusnya. Kesimpulan lain apa lagi yang bisa kita tarik dari hal ini? Ya, baris hasil = x * hasil dijalankan sebanyak y kali! Secara sederhana, tabel di bawah menampilkan berapa kali setiap baris yang ada dalam fungsi pangkat dieksekusi:
Baris Kode " Jumlah Eksekusi
hasil = 1 " 1
hasil = x * hasil " y
return hasil " 1
sehingga kita dapat mengatakan bahwa fungsi pangkat akan selalu diselesaikan dalam 2 + y langkah. Melihat bagiamana y akan mempengaruhi jumlah langkah eksekusi, mari kita lihat seberapa banyak pengaruh y terhadap jumlah langkah eksekusi kode:
Y
Proses Perhitungan
Jumlah Langkah
1
2 + 1
3
10
2 + 10
12
100
2 + 100
102
1000
2 + 1000
1002
10000
2 + 10000
10002
Dari tabel di atas kita dapat melihat bagiamana semakin meningkatnya jumlah dari y, semakin nilai 2 yang ditambahkan menjadi tidak relevan. Perbedaan jumlah langkah 1000000 dengan 1000002 tentunya tidak banyak! Dengan begitu, kita dapat menyederhanakan fungsi perhitungan jumlah langkah pangkat dengan mengatakan bahwa fungsi pangkat akan selalu diselesaikan dalam y langkah. Dengan kata lain, kecepatan atau efisiensi dari fungsi pangkat bergantung kepada y.
Semakin besar nilai y, maka jumlah langkah eksekusi akan semakin meningkat. Hal ini tentunya sangat berpengaruh terhadap efisiensi total dari sebuah algoritma. Bayangkan jika jumlah langkah yang diperlukan bukanlah y, melainkan \(y^2\):
Y
Jumlah Langkah (\(y\))
Jumlah Langkah (\(y^2\))
1
1
1
10
10
100
100
100
10000
1000
1000
1000000
10000
10000
100000000
Perhatikan bagaimana pertumbuhan jumlah langkah terus menerus meningkat tajam, setiap kali kita menambahkan nilai y 10 kali lipat. Untuk memperjelas perbedaan pertumbuhan lagi, perhatikan gambar berikut:

Tingkat Pertumbuhan Fungsi Pangkat
Peningkatan jumlah langkah eksekusi seperti inilah yang menyebabkan kita mengukur efisiensi algoritma dengan ukuran pertumbuhan jumlah langkah eksekusi relatif terhadap jumlah data. Melihat grafik pertumbuhan yang diberikan, fungsi pangkat yang dikembangkan dapat dikatakan memiliki tingkat pertumbuhan yang linear.
Notasi Asimtotik
Perhitungan pertumbuhan fungsi seperti yang kita lakukan sebelumnya sangat krusial dalam menghitung efisiensi sebuah algoritma. Seperti layaknya hal-hal krusial lainnya pada ilmu komputer, tentunya fungsi pertumbuhan ini juga memiliki notasi matematika khusus. Penulisan fungsi pertumbuhan dilakukan dengan menggunakan notasi asmtotik.
Terdapat beberapa jenis notasi asimtotik, tetapi kita hanya akan menggunakan dan membahas satu notasi saja, yaitu notasi Big-O. Big-O dipilih karena merupakan notasi yang paling populer dan paling banyak digunakan pada kalangan peneliti ilmu komputer. Notasi Big-O digunakan untuk mengkategorikan algoritma ke dalam fungsi yang menggambarkan batas atas (upper limit) dari pertumbuhan sebuah fungsi ketika masukan dari fungsi tersebut bertambah banyak. Singkatnya, perhitungan jumlah langkah dan pertumbuhannya yang kita lakukan pada bagian sebelumnya merupakan langkah-langkah untuk mendapatkan fungsi Big-O dari sebuah algoritma.
Big-O, seperti namanya, dituliskan sebagai fungsi "O" dengan nilai masukan berupa tingkat pertumbuhan dari fungsi yang dijabarkan. Misalnya, algoritma perpangkatan dengan pertumbuhan linear yang kita kembangkan pada bagian sebelumnya memiliki kelas Big-O \(O(n)\).
Karena berguna untuk mengkategorikan algoritma, terdapat beberapa jenis kelas efisiensi umum yang dijumpai dalam Big-O, yaitu:
Fungsi Big-O
Nama
\(O(1)\)
Konstan
\(O(\log n)\)
Logaritmik
\(O(n)\)
Linear
\(O(n \log n)\)
n log n
\(O(n^2)\)
Kuadratik
\(O(n^m)\)
Polinomiale
\(O(n!)\)
Faktorial
Apa guna dan penjelasan dari masing-masing kelas kompleksitas yang ada? Mari kita lihat satu per satu.
Kriteria Efisiensi Umum
Bagian ini akan menjelaskan beberapa contoh kriteria kompleksitas algoritma yang umum dijumpai, beserta dengan contoh kode algoritma yang memiliki kompleksitas tersebut.
O(1): Kompleksitas Konstan
Sebuah algoritma yang memiliki kompleksitas konstan tidak bertumbuh berdasarkan ukuran dari data atau masukan yang diterima algoritma tersebut. Bahkan, algoritma dengan kompleksitas ini tidak akan bertumbuh sama sekali. Berapapun ukuran data atau masukan yang diterima, algoritma dengan kompleksitas konstan akan memiliki jumlah langkah yang sama untuk dieksekusi.
Karena sifatnya yang selalu memiliki jumlah langkah tetap, algoritma dengan kompleksitas merupakan algoritma paling efisien dari seluruh kriteria yang ada. Contoh dari algoritma yang memiliki kompleksitas konstan ialah algoritma yang digunakan untuk menambahkan elemen baru ke dalam linked list. Contoh implementasi algoritma ini pada bahasa C adalah sebagai berikut:
void add_list(node *anchor, node *new_list)
{
new_list->next = anchor->next;
anchor->next = new_list;
}
Seperti yang dapat dilihat pada kode di atas, algoritma untuk menambahkan elemen baru ke dalam linked list tidak memerlukan perulangan, percabangan, ataupun banyak langkah. Untuk menambahkan elemen baru, kita cukup menjalankan dua langkah saja, tidak peduli berapapun ukuran awal dari linked list yang ada. Dengan kata lain, berapapun ukuran linked list awal, langkah untuk untuk menambahkan elemen baru adalah konstan, yaitu dua langkah. Hal ini lah yang menyebabkan algoritma ini dikatakan memiliki kompleksitas konstan.
Tingkat pertumbuhan dari algoritma dengan kompleksitas konstan dapat dilihat pada gambar berikut:

Tingkat Pertumbunan Algoritma Kompleksitas Konstan
O(log n): Kompleksitas Logaritmik
Algoritma dengan kompleksitas logaritmik merupakan algoritma yang menyelesaikan masalah dengan membagi-bagi masalah tersebut menjadi beberapa bagian, sehingga masalah dapat diselesaikan tanpa harus melakukan komputasi atau pengecekan terhadap seluruh masukan. Contoh algoritma yang ada dalam kelas ini adalah algoritma binary search. Mari kita hitung nilai kompleksitas dari binary search!
Berikut adalah implementasi dari binary search dengan bahasa python:
def binary_search(lst, search):
lower_bound = 0
upper_bound = len(lst) - 1

while True:
if upper_bound < lower_bound:
print("Not found.")
return -1

i = (lower_bound + upper_bound) // 2

if lst[i] < search:
lower_bound = i + 1
elif lst[i] > search:
upper_bound = i - 1
else:
print("Element " + str(search) + " in " + str(i))
return 0
Mari kita hitung jumlah langkah yang diperlukan untuk mendapatkan kelas kompleksitas dari binary search. Berikut adalah tahapan perhitungan untuk mendapatkan jumlah langkah yang diperlukan:
Langkah yang akan selalu dieksekusi pada awal fungsi, yaitu inisialisasi lower_bound dan upper_bound: 2 langkah.
Pengecekan kondisi while (pengecekan tetap dilakukan, walaupun tidak ada perbandingan yang dijalankan): 1 langkah.
Pengecekan awal (if upper_bound < lower_bound): 1 langkah.
Inialisasi i: 1 langkah.
Pengecekan kondisi kedua (if lst[i] < search: ...), kasus terburuk (masuk pada else dan menjalankan kode di dalamnya): 4 langkah.
Dan setelah melalui langkah kelima, jika elemen belum ditemukan maka kita akan kembali ke langkah kedua. Perhatikan bahwa sejauh ini, meskipun elemen belum ditemukan atau dianggap tidak ditemukan, kita minimal harus menjalankan 2 langkah dan pada setiap perulangan while kita menjalankan 7 langkah. Sampai di titik ini, model matematika untuk fungsi Big-O yang kita dapatkan ialah seperti berikut:
\[f(n) = 2 + 7(\text{jumlah perulangan})\]
Pertanyaan berikutnya, tentunya adalah berapa kali kita harus melakukan perulangan? Berhentinya kondisi perulangan ditentukan oleh dua hal, yaitu:
Kondisi upper_bound < lower_bound, dan
Pengujian apakah lst[i] == search, yang diimplikasikan oleh perintah else.
Perhatikan juga bagaimana baik nilai upper_bound maupun lower_bound dipengaruhi secara langsung oleh i, sehingga dapat dikatakan bahwa kunci dari berhentinya perulangan ada pada i. Melalui baris kode ini:
i = (lower_bound + upper_bound) // 2
Kita melihat bahwa pada setiap iterasinya nilai i dibagi 2, sehingga untuk setiap iterasinya kita memotong jumlah data yang akan diproses (\(n\)) sebanyak setengahnya. Sejauh ini kita memiliki model matematika seperti berikut (konstanta \(2\) dihilangkan karena tidak berpengaruh):
\[f(n) = 7f(\frac{n}{2})\]
yang jika diturunkan lebih lanjut akan menjadi:
\[\begin{split}f(n) & = 7f(\frac{n}{2}) \\ & = 7 * (7f(\frac{n}{4})) \\ & = 49f(\frac{n}{4}) \\ & = 49 * (7f(\frac{n}{8})) \\ & ... \\ & = 7^k f(\frac{n}{2^k})\end{split}\]
di mana kita ketahui kondisi dari pemberhentian perulangan adalah ketika sisa elemen list adalah 1, dengan kata lain:
\[\begin{split}\frac{n}{2^k} & = 1 \\ n & = 2^k \\ \log_2 n & = k\end{split}\]
Sehingga dapat dikatakan bahwa binary search memiliki kompleksitas \(O(\log_2n)\), atau sederhananya, \(O(\log n)\).
Tingkat pertumbuhan algoritma dengan kompleksitas logaritmik dapat dilihat pada gambar berikut:

Tingkat Pertumbunan Algoritma Kompleksitas Logaritmik
O(n): Kompleksitas Linear
Algoritma dengan kompleksitas linear bertumbuh selaras dengan pertumbuhan ukuran data. Jika algoritma ini memerlukan 10 langkah untuk menyelesaikan kalkulasi data berukuran 10, maka ia akan memerlukan 100 langkah untuk data berukuran 100. Contoh dari algoritma dengan kompleksitas linear telah diberikan pada bagian sebelumnya, yaitu perhitungan pangkat bilangan. Contoh lain dari algoritma dengan kompleksitas linear adalah linear search.
Linear search melakukan pencarian dengan menelusuri elemen-elemen dalam list satu demi satu, mulai dari indeks paling rendah sampai indeks terakhir. Berikut adalah implementasi dari linear search pada python:
def linear_search(lst, search):
for i in range(0, len(lst)):
if lst[i] == search:
print("Nilai ditemukan pada posisi " + str(i))
return 0
print("Nilai tidak ditemukan.")
return -1
Dengan menggunakan cara perhitungan yang sama pada perhitungan pangkat, kita bisa mendapatkan jumlah eksekusi kode seperti berikut (dengan asumsi n = len(lst)):
Kode
Jumlah Eksekusi
for i in range(0, len(lst))
\(1\)
if lst[i] == search
\(n\)
print("Nilai ditemukan...
\(1\)
return 0
\(1\)
print("Nilai tidak ...
\(1\)
return -1
\(1\)
Sehingga nilai kompleksitas dari linear search adalah \(5 + n\), atau dapat dituliskan sebagai \(O(n)\). Adapun grafik pertumbuhan untuk kompleksitas \(O(n)\) adalah seperti berikut:

Tingkat Pertumbunan Algoritma Kompleksitas Linear
O(n log n)
Algoritma dengan kompleksitas \(n \log n\) memiliki cara perhitungan yang sangat mirip dengan algoritma \(\log n\). Pada dasarnya algoritma kelas ini merupakan algoritma \(\log n\) yang dijalankan sebenyak \(n\) kali. Contoh sederhananya, misalkan kita diminta untuk mencari sepasang bilangan di dalam sebuah list yang jika ditambahkan akan bernilai 0. Asumsikan list yang diberikan sudah terurut.
Salah satu solusi yang paling sederhana ialah dengan menelusuri seluruh list, satu demi satu (kompleksitas: \(n\)) lalu mencari elemen yang bernilai invers dari elemen sekarang menggunakan binary search (kompleksitas: \(\log n\)). Mari kita lihat contoh implementasi dari fungsi ini terlebih dahulu:
def zero_sum(lst):
n = len(lst)
for i in range(0, n):
j = binary_search(lst, -1 * lst[i])
if j > i:
n1 = str(lst[i])
n2 = str(lst[j])
print("Zero sum: " + n1 + " and " + n2 + "\n")
Perhatikan bagaimana kita melakukan binary search sebanyak \(n\) kali, sehingga secara sederhana kompleksitas yang akan kita dapatkan adalah \(n * \log n = n \log n\). Adapun grafik pertumbuhan untuk kompleksitas \(O(n \log n)\) adalah seperti berikut:

Tingkat Pertumbunan Algoritma Kompleksitas n log n
O(\(n^m\)): Kompleksitas Polinomial
Algoritma dengan kompleksitas polinomial merupakan salah satu kelas algoritma yang tidak efisien, karena memerlukan jumlah langkah penyelesaian yang jauh lebih besar daripada jumlah data. Untuk lebih jelasnya, mari kita lihat salah satu contoh algoritma yang memiliki kompleksitas polinomial:
def kali(a, b):
res = 0
for i in range(a):
for j in range(b):
res += 1
return res
Algoritma di atas melakukan perkalian antara \(a\) dan \(b\), dengan melakukan penambahan \(1\) sebanyak \(b\) kali, yang hasilnya ditambahkan sebanyak \(a\) kali. Mengabaikan dua langkah, yaitu awal (res = 0) dan akhir (return res) kode, kita dapat melihat total langkah yang diperlukan oleh perulangan bersarang yang ada seperti berikut:
Kode
Jumlah Langkah
for i in range(b):
\(a\)
res += 1
\(b\)
dan karena pada setiap iterasi kita harus menjalankan kode for i in range(b), maka dapat dikatakan kompleksitas dari kode di atas adalah:
\[a * b\]
yang ketika nilai \(a\) dan \(b\) sama akan menjadi:
\[a^2\]
atau dapat ditulis sebagai \(n^2\) yang diabstrakkan sebagai \(n^m, m = 2\). Grafik pertumbuhan untuk kompleksitas polinomial adalah sebagai berikut:

Tingkat Pertumbunan Algoritma Kompleksitas Eksponensial
Perbandingan Pertumbuhan Seluruh Kompleksitas
Setelah melihat seluruh nilai kompleksitas yang ada, tentunya kita dapat melihat kelas algoritma yang paling efisien dan paling tidak efisien. Gambar berikut memperlihatkan perbandingan tingkat pertumbuhan antara masing-masing kompleksitas yang telah dipelajari:

Perbandingan Tingkat Pertumbuhan Tiap Kompleksitas
Pengembangan algoritma idealnya diusahakan mendapatkan kompleksitas \(O(1)\) atau \(O(\log n)\). Sayangnya pada kenyataannya kita tidak akan selalu mendapatkan kompleksitas terbaik dalam merancang algoritma. Jika tidak dapat mencapai kompleksitas maksimal, hal terbaik yang dapat kita lakukan ketika mengembangkan solusi dari masalah adalah melihat apakah masalah yang ada dapat diselesaikan dengan algoritma yang ada terlebih dahulu, sebelum mengembangkan algoritma baru. Hal ini memastikan kita mendapatkan kompleksitas yang paling efisien sampai saat pengembangan solusi.
Kesimpulan
Pada bagian ini kita telah mempelajari bagaimana melakukan analisa efisiensi algoritma dengan menggunakan notasi Big-O. Kita juga melihat bagaimana algoritma yang paling efisien memiliki kompleksitas \(O(1)\), dengan kompleksitas \(O(n!)\) sebagai kelas kompleksitas yang paling tidak efisien. Dengan mengerti efisiensi algoritma, diharapkan pembaca dapat memilih dan merancang algoritma yang sesuai dengan kebutuhan untuk menyelesaikan masalah.
Pada bagian selanjutnya kita akan mulai mengembangkan algoritma dengan menggunakan konsep pemrograman.
Rekursif
Salah satu konsep paling dasar dalam ilmu komputer dan pemrograman adalah pengunaan fungsi sebagai abstraksi untuk kode-kode yang digunakan berulang kali. Kedekatan ilmu komputer dengan matematika juga menyebabkan konsep-konsep fungsi pada matematika seringkali dijumpai. Salah satu konsep fungsi pada matematika yang ditemui pada ilmu komputer adalah fungsi rekursif: sebuah fungsi yang memanggil dirinya sendiri.
Kode berikut memperlihatkan contoh fungsi rekursif, untuk menghitung hasil kali dari dua bilangan:
def kali(a, b):
return a if b == 1 else a + kali(a, b - 1)
Bagaimana cara kerja fungsi rekursif ini? Sederhananya, selama nilai b bukan 1, fungsi akan terus memanggil perintah a + kali(a, b - 1), yang tiap tahapnya memanggil dirinya sendiri sambil mengurangi nilai b. Mari kita coba panggil fungsi kali dan uraikan langkah pemanggilannya:
kali(2, 4)
-> 2 + kali(2, 3)
-> 2 + (2 + kali(2, 2))
-> 2 + (2 + (2 + kali(2, 1)))
-> 2 + (2 + (2 + 2))
-> 2 + (2 + 4)
-> 2 + 6
-> 8
Perhatikan bahwa sebelum melakukan penambahan program melakukan pemanggilan fungsi rekursif terlebih dahulu sampai fungsi rekursif mengembalikan nilai pasti (\(2\)). Setelah menghilangkan semua pemanggilan fungsi, penambahan baru dilakukan, mulai dari nilai kembalian dari fungsi yang paling terakhir. Mari kita lihat contoh fungsi rekursif lainnya, yang digunakan untuk melakukan perhitungan faktorial:
def faktorial(n):
return n if n == 1 else n * faktorial(n - 1)
Fungsi faktorial memiliki cara kerja yang sama dengan fungsi kali. Mari kita panggil dan lihat langkah pemanggilannya:
faktorial(5)
-> 5 * faktorial(4)
-> 5 * (4 * faktorial(3))
-> 5 * (4 * (3 * faktorial(2)))
-> 5 * (4 * (3 * (2 * faktorial(1))))
-> 5 * (4 * (3 * (2 * 1)))
-> 5 * (4 * (3 * 2))
-> 5 * (4 * 6)
-> 5 * 24
-> 120
Dengan melihat kemiripan cara kerja serta kode dari fungsi faktorial dan kali, kita dapat melihat bagaimana fungsi rekursif memiliki dua ciri khas:
Fungsi rekursif selalu memiliki kondisi yang menyatakan kapan fungsi tersebut berhenti. Kondisi ini harus dapat dibuktikan akan tercapai, karena jika tidak tercapai maka kita tidak dapat membuktikan bahwa fungsi akan berhenti, yang berarti algoritma kita tidak benar.
Fungsi rekursif selalu memanggil dirinya sendiri sambil mengurangi atau memecahkan data masukan setiap panggilannya. Hal ini penting diingat, karena tujuan utama dari rekursif ialah memecahkan masalah dengan mengurangi masalah tersebut menjadi masalah-masalah kecil.
Setiap fungsi rekursif yang ada harus memenuhi kedua persyaratan di atas untuk memastikan fungsi rekursif dapat berhenti dan memberikan hasil. Kebenaran dari nilai yang dihasilkan tentu saja memerlukan pembuktian dengan cara tersendiri. Tetapi sebelum masuk ke analisa dan pembuktian fungsi rekursif, mari kita lihat kegunaan dan contoh-contoh fungsi rekursif lainnya lagi.
Fungsi Rekursif dan Iterasi
Pembaca yang jeli akan menyadari bahwa kedua contoh fungsi rekursif yang diberikan sebelumnya, faktorial dan kali, dapat diimplementasikan tanpa menggunakan fungsi rekursif. Berikut adalah contoh kode untuk perhitungan faktorial tanpa menggunakan rekursif:
def faktorial_iterasi(n):
hasil = 1
for i in range(1, n + 1):
hasil = hasil * i
return hasil
Dalam menghitung nilai faktorial menggunakan iterasi, kita meningkatkan nilai hasil terus menerus, sampai mendapatkan jawaban yang tepat. Yang perlu kita pastikan benar pada fungsi ini adalah berapa kali kita harus meningkatkan nilai hasil. Jika jumlah peningkatan salah, maka hasil akhir yang didapatkan juga akan salah.
Pendekatan iteratif berbeda dengan rekursif dalam hal ini: jika pendekatan rekursif memecah-mecah masalah untuk kemudian menyelesaikan masalah sedikit demi sedikit, pendekatan iteratif justru langsung mencoba menyelesaikan masalah, tanpa memecah-mecahkan masalah tersebut menjadi lebih kecil terlebih dahulu. Untungnya, baik teknik iterasi maupun rekursi sama-sama memiliki tingkat ekspresi yang sama: segala hal yang dapat diselesaikan dengan itearsi akan dapat diselesaikan dengan rekursif. Lalu, kapan dan kenapa kita harus menggunakan rekursif?
Meskipun dapat menyelesaikan masalah yang sama, terdapat beberapa permasalahan atau solusi yang lebih tepat diselesaikan dengan menggunakan fungsi rekursif. Salah satu contoh dari masalah ini adalah penelurusan data di dalam sebuah binary tree. Sebuah binary tree, yang dapat didefinisikan sebagai sebuah pohon dengan jumlah cabang yang selalu dua, secara alami adalah struktur data rekursif.

Binary Tree
Sebagai struktur rekursif, tentunya penelusuran binary tree akan lebih mudah dilakukan secara rekursif dibandingkan iterasi. Hal ini sangat kontras dengan, misalnya, pencarian karakter di dalam string. Sebagai data yang disimpan secara linear, pencarian karakter dalam string akan lebih mudah untuk dilakukan secara iteratif.
Untuk mempermudah ilustrasi, mari kita lakukan perbandingan antara implementasi rekursif dan iteratif untuk masalah yang lebih cocok diselesaikan dengan masing-masing pendekatan. Misalnya, implementasi algoritma euclidean untuk menghitung faktor persekutuan terbesar (FPB) yang lebih cocok untuk diimplementasikan dengan metode rekursif seperti berikut:
def gcd(x, y):
return x if y == 0 else gcd(y, x % y)
yang jika diimplementasikan dengan menggunakan iterasi adalah sebagai berikut:
def gcd_iterasi(x, y):
while y != 0:
temp = y
y = x % temp
x = temp
return x
Jika dibandingkan dengan fungsi matematis dari algoritma euclidean:
\[\begin{split}gcd(x, y) = \begin{cases} x & \text{if } y = 0 \\ gcd(y, remainder(x, y)) & \text{if } y > 0 \end{cases}\end{split}\]
tentunya implementasi secara rekursif lebih sederhana dan mudah dimengerti dibandingkan dengan secara iterasi.
Sekarang mari kita lihat contoh algoritima yang lebih cocok diimplementasikan secara iteratif, misalnya linear search. Implementasi standar linear search secara iteratif adalah sebagai berikut:
def linear_search(lst, search):
for i in range(0, len(lst)):
if lst[i] == search:
print("Nilai ditemukan pada posisi: " + str(i))
return 0
print("Nilai tidak ditemukan")
return -1
yang jika diimplementasikan secara rekursif akan menjadi:
def linear_search_rec(lst, search, pos):
if len(lst) <= pos:
print("Nilai tidak ditemukan.")
return -1
elif lst[pos] == search:
print("Nilai ditemukan di posisi: " + str(pos))
return 0
else:
return linear_search_rec(lst, search, pos + 1)
Perhatikan bagaimana diperlukan lebih banyak pengecekan pada fungsi rekursif, serta tambahan parameter pos yang berguna untuk menyimpan posisi pengujian dan ditemukannya elemen yang dicari. Jika menggunakan iterasi variabel pos tidak dibutuhkan lagi karena posisi ini akan didapatkan secara otomatis ketika sedang menelusuri list. Dengan melihat jumlah argumen dan pengecekan yang harus dilakukan, dapat dilihat bahwa implementasi linear search menjadi lebih sederhana dan mudah dengan menggunakan metode iterasi.
Tail Call
Sesuai definisinya, dalam membuat fungsi rekursif pada satu titik kita akan harus memanggil fungsi itu sendiri. Pemanggilan diri sendiri di dalam fungsi tentunya memiliki konsekuensi tersendiri, yaitu pengunaan memori. Dengan memanggil dirinya sendiri, secara otomatis sebuah fungsi akan memerlukan memori tambahan, untuk menampung seluruh variabel baru serta proses yang harus dilakukan terhadap nilai-nilai baru tersebut. Penambahan memori ini seringkali menyebabkan stack overflow ketika terjadi pemanggilan rekursif yang terlalu banyak.
Untuk menanggulangi kesalahan stack overflow ini, para pengembang bahasa pemrograman mengimplementasikan apa yang dikenal dengan tail call optimization. Dalam merancang dan menganalisa algoritma rekursif, pengertian akan tail call optimization merupakan hal yang sangat penting. Jadi, apa itu tail call?
Tail call merupakan pemanggilan fungsi sebagai perintah terakhir di dalam fungsi lain. Sederhananya, ketika kita memanggil sebuah fungsi pada bagian akhir dari fungsi lain, kita melakukan tail call, seperti pada kode di bawah:
def fungsi(x):
y = x + 10
return fungsi_lain(y)
Pada kode di atas, pemanggilan fungsi_lain sebagai kode terakhir yang dieksekusi oleh fungsi dapat dikatakan sebagai tail call. Ingat juga bahwa pemanggilan tidak harus berada di akhir fungsi secara fisik. Yang penting adalah bahwa kode terakhir yang dieksekusi adalah pemanggilan fungsi lain:
def tail_call(n):
if n == 0:
return fungsi_1(n + 1)
else:
return fungsi_2(n)
Pada contoh fungsi tail_call di atas, pemanggilan terhadap fungsi_1 maupun fungsi_2 adalah tail call, meskipun pemanggilan fungsi_1 tidak berada pada akhri fungsi secara fisik. Bandingkan dengan kode berikut:
def bukan_tail_call(n):
result = fungsi_lain(n % 5)
return result * 10
yang bukan merupakan tail call, karena kode terakhir yang dieksekusi (result * 10e) adalah sebuah operasi, bukan pemanggilan fungsi. Cara kerja ini tentunya juga dibawa ke fungsi rekursif, di mana:
def faktorial(n):
if n == 1:
return 1
else:
return n * faktorial(n - 1)
bukan merupakan tail call karena baik return 1 maupun n * faktorial(n - 1) bukanlah pemanggilan fungsi. Ingat bahwa n * faktorial(n - 1) merupakan operator perkalian, bukan pemanggilan fungsi karena faktorial(n - 1) akan harus mengembalikan hasil terlebih dahulu agar bisa dikalikan dengan n. Jika ingin membuat fungsi rekursif yang memanfaatkan tail call, kita harus memastikan kode terakhir yang dieksekusi adalah fungsi lain, tanpa operasi lanjutan. Misalnya, kita dapat menyimpan hasil kalkulasi sebagai parameter, seperti berikut:
def faktorial_tc(n, r = 1):
if n <= 1:
return r
else:
return faktorial_tc(n - 1, n * r)
untuk memastikan terdapat tail call di dalam fungsi.
Implementasi algoritma rekursif disarankan untuk mengadopsi tail call, karena natur dari fungsi rekursif yang memakan banyak memori. Tail call optimization, jika diimplementasikan oleh bahasa pemrograman, akan mendeteksi adanya tail call pada sebuah fungsi untuk kemudian dijalankan sebagai perulangan untuk menghindari penggunaan memori berlebihan.
Bahasa pemrograman yang mendukung tail call optimization biasanya adalah bahasa pemrograman fungsional seperti Haskell, LISP, Scheme, dan Erlang. Python, sayangnya, tidak mendukung optimization.
Analisis Algoritma Rekursif
Melakukan analisis untuk algoritma rekursif pada dasarnya sama dengan melakukan analisis terhadap algoritma imparatif lain. Perbedaan utama pada algoritma rekursif ialah kita tidak dapat secara langsung melihat berapa kali bagian rekursif dari algoritma akan dijalankan. Pada algoritma yang menggunakan perulangan for misalnya, kita dapat langsung menghitung jumlah perulangan untuk menghitung total langkah yang dibutuhkan. Dalam algoritma rekursif, jumlah perulangan tidak secara eksplisit bisa didapatkan karena informasi yang kita miliki adalah kapan algoritma berhenti, bukan berapa kali kode dieksekusi.
Misalnya, algoritma perhitungan faktorial yang telah dibahas sebelumnya:
def faktorial(n):
return n if n == 1 else n * faktorial(n - 1)
Salah satu informasi yang didapatkan di sini adalah kapan algoritma berhenti melakukan rekursif, yaitu n == 1. Informasi lain yang kita miliki adalah berkurangnya jumlah data pada setiap pemanggilan faktorial. Bagaimana kita melakukan analisis algoritma ini? Cara termudahnya adalah dengan menggambarkan fungsi matematika dari faktorial terlebih dahulu:
\[\begin{split}faktorial(n) = \begin{cases} 1 & \text{if } n = 1 \\ n * faktorial(n - 1) remainder(x, y)) & \text{if } n > 1 \end{cases}\end{split}\]
Melalui fungsi matematika ini, kita dapat mulai melakukan penurunan untuk fungsi perhitungan langkah fungsi \(faktorial\) untuk kasus \(n > 1\):
\[\begin{split}f(n) & = 1 + f(n - 1) \\ & = 1 + 1 + f(n - 2) \\ & = 1 + 1 + 1 + f(n - 3) \\ & ... \\ & = n + f(n - k)\end{split}\]
Dan tentunya kita dapat mengabaikan penambahan langkah \(n\) di awal, serta dengan syarat bahwa fungsi berhenti ketika \(n - k = 1\):
\[\begin{split}n - k & = 1 \\ k & = n - 1 \\\end{split}\]
Maka dapat disimpulkan bahwa fungsi faktorial memiliki kompleksitas \(n - 1\), atau \(O(n)\). Ingat bahwa kunci dari perhitungan kompleksitas untuk algoritma rekursif terdapat pada fungsi matematis algoritma dan definisi kapan berhentinya fungsi rekursif tersebut.
Kesimpulan
Fungsi rekursif merupakan fungsi yang memanggil dirinya sendiri. Terdapat dua komponen penting dalam fungsi rekursif, yaitu kondisi kapan berhentinya fungsi dan pengurangan atau pembagian data ketika fungsi memanggil dirinya sendiri. Optimasi fungsi rekursif dapat dilakukan dengan menggunakan teknik tail call, meskipun teknik ini tidak selalu diimplementasikan oleh semua bahasa pemrograman.
Selain sebagai fungsi, konsep rekursif juga terkadang digunakan untuk struktur data seperti binary tree atau list.
Divide and Conquer
Komputer pada awalnya diciptakan sebagai perangkat untuk melakukan kalkulasi secara otomatis dan akurat. Meskipun awalnya hanya berfokus pada kalkukasi numerik, komputer modern yang dijumpai sekarang telah melakukan kalkulasi pada banyak hal, seperti teks ataupun gambar. Berbagai kalkulasi dan analisa yang dilakukan komputer biasanya diimplementasikan melalui perangkat lunak. Dengan semakin besarnya ruang lingkup hal-hal yang dilakukan oleh komputer, perangkat lunak yang dikembangkan juga menjadi semakin kompleks. Algoritma, sebagai bagian dari perangkat lunak yang melakukan pemrosesan, juga memerlukan berbagai teknik baru. Misalkan, untuk menghitung total jumlah dari bilangan-bilangan yang ada di dalam sebuah list, kita dapat menggunakan perulangan sederhana:
nums = [1, 2, 3, 5, 6, 7, 19, 28, 58, 18, 28, 67, 13]
total = 0

for i in range(0, len(nums)):
total = total + nums[i]

print(total) # 255
Algoritma perulangan yang digunakan pada kode di atas memang sederhana dan memberikan hasil yang benar, tetapi terdapat beberapa masalah pada kode tersebut, yaitu perhitungan dilakukan secara linear, yang menghasilkan kompleksitas \(O(n)\). Hal ini tentunya cukup ideal untuk ukuran list kecil, tetapi jika ukuran list menjadi besar (beberapa Milyar elemen) maka perhitungan akan menjadi sangat lambat. Kenapa perhitungannya menjadi lambat? Karena nilai dari total tergantung kepada kalkulasi nilai total sebelumnya. Kita tidak dapat melakukan perhitungan total dari depan dan belakang list sekaligus, sehingga kita dapat mempercepat perhitungan dua kali lipat. Dengan kode di atas, kita tidak dapat membagi-bagikan pekerjaan ke banyak pekerja / CPU!
Lalu apa yang dapat kita lakukan? Langkah pertama yang dapat kita lakukan adalah menerapkan teknik rekursif untuk membagi-bagikan masalah menjadi masalah yang lebih kecil. Jika awalnya kita harus menghitung total keseluruhan list satu per satu, sekarang kita dapat melakukan perhitungan dengan memecah-mecah list terlebih dahulu:
def sums(lst):
if len(lst) >= 1:
return lst[0]

mid = len(lst) // 2
left = sums(lst[:mid])
right = sums(lst[mid:])

return left + right

print(sums(nums)) # 255
Apa yang kita lakukan pada kode di atas?
Baris if len(lst) >= 1 memberikan syarat pemberhentian fungsi rekursif, yang akan mengembalikan isi dari list ketika list berukuran 1 (hanya memiliki satu elemen).
Baris mid = len(lst) // 2 mengambil median dari list, sebagai referensi ketika kita membagi list menjadi dua bagian.
Baris left = sum(lst[:mid]) dan selanjutnya membagikan list menjadi dua bagian, dengan nilai mid sebagai tengah dari list.
Singkatnya, setelah membagikan list menjadi dua bagian terus menerus sampai bagian terkecilnya, kita menjumlahkan kedua nilai list tersebut, seperti pada gambar berikut:

Langkah Kerja Divide and Conquer
Apa kelebihan pendekatan dengan membagi-bagikan masalah ini? Dengan menggunakan bahasa dan library yang tepat, kita dapat membagi-bagikan setiap bagian rekursif (left = ... dan right = ...) ke satu unit kerja baru, yang dikenal dengan nama thread. Mekanisme pada sistem operasi atau compiler kemudian akan membagi-bagikan tugas pembagian dan perhitungan lanjutan agar dapat dijalankan secara paralel, misalnya dengan membagikan tugas ke dalam beberapa core prosesor, atau bahkan ke dalam mesin lain (jika terdapat sistem dengan banyak mesin).
Dengan membagi-bagikan pekerjaan ke dalam banyak unit, tentunya pekerjaan akan lebih cepat selesai! Teknik memecah-mecah pekerjaan untuk kemudian dibagikan kepada banyak pekerja ini dikenal dengan nama divide and conquer.
Membangun Algoritma Divide and Conquer
Sebuah algoritma divide and conquer (selanjutnya disebut dengan D&C) memiliki tiga langkah, yaitu:
Divide (Memecah): pada langkah ini kita memecahkan masalah atau data ke dalam bentuk yang sama, tetapi dalam ukuran yang lebih kecil. Pemecahan langkah biasanya dilakukan dengan menggunakan algoritma rekursif, sampai ukuran data menjadi sangat kecil dan dapat diselesaikan dengan algoritma sederhana.
Conquer (Menaklukkan): dalam langkah ini kita mencoba menyelesaikan masalah atau data yang telah dipecahkan pada langkah pertama, dengan menggunakan algoritma sederhana.
Combine (Menggabungkan): setelah menjalankan langkah conquer, tentunya kita harus menggabungkan kembali hasil dari masing-masing pecahan yang ada, untuk mendapatkan hasil akhir kalkulasi. Langkah combine mencoba mencapai hal tersebut.
Algoritma D&C, jika diimplementasikan menggunakan library atau bahasa yang tepat akan meningkatkan efisiensi algoritma secara logaritmik. Mari kita lakukan analisis pada fungsi sum di atas, untuk melihat kompleksitas algoritmanya:
def sums(lst):
if len(lst) >= 1: # 1 langkah
return lst[0] # 1 langkah

mid = len(lst) // 2 # 1 langkah
left = sums(lst[:mid]) # sums(mid) langkah
right = sums(lst[mid:]) # sums(mid) langkah

return left + right # 1 langkah
yang secara matematis dapat dituliskan seperti berikut:
\[\begin{split}f(n) & = 4 + f(\frac{n}{2}) + f(\frac{n}{2}) \\ & = 4 + 2f(\frac{n}{2})\end{split}\]
karena ukuran dari mid adalah panjang list (\(n\)) dibagi dua. Dengan begitu, kompleksitas dari algoritma adalah:
\[\begin{split}f(n) & = 2f(\frac{n}{2}) \\ & = 2(2(\frac{n}{4})) \\ & = 2(2(2(\frac{n}{8}))) \\ & ... \\ & = 2^k(\frac{n}{2^k})\end{split}\]
dengan syarat berhenti adalah ketika \(k \geq 1\), sehingga:
\[\begin{split}\frac{n}{2^k} & = 1 \\ n & = 2^k \\ k & = \log_2 n\end{split}\]
Kompleksitas dari fungsi sums adalah \(O(\log n)\), meningkat dari \(O(n)\) pada algoritma awal!
Secara umum, kompleksitas algoritma D&C adalah \(O(n \log n)\), jika ukuran data adalah \(n\), dan pada setiap langkahnya kita membagikan masalah ke dalam \(p\) sub-masalah.
Contoh D&C 1: Merge Sort
Merge sort, seperti namanya, merupakan algoritma yang dirancang untuk melakukan pengurutan terhadap sekumpulan bilangan. Ide utama dari merge sort sama dengan algoritma perhitungan total yang telah kita lakukan sebelumnya, yaitu membagi-bagikan keseluruhan list menjadi komponen kecil, dan kemudian mengurutkan komponen tersebut dan menggabungkannya kembali menjadi sebuah list besar.
Berikut adalah merge sort yang diimplementasikan dalam bahasa python:
def merge_sort(lst):
if len(lst) <= 1:
return lst

mid = len(lst) // 2
left = merge_sort(lst[:mid])
right = merge_sort(lst[mid:])

return merge(left, right)

def merge(left, right):
result = []

while len(left) > 0 or len(right) > 0:
if len(left) > 0 and len(right) > 0:
if left[0] <= right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
elif len(left) > 0:
result.append(left.pop(0))
elif len(right) > 0:
result.append(right.pop(0))

return result
Dari kode di atas terlihat bahwa merge sort memiliki dua bagian, yang dituliskan dalam dua buah fungsi: merge dan merge_sort. Fungsi merge_sort memiliki logika dan cara kerja yang sama dengan fungsi penjumlahan total yang kita bangun sebelumnya, dengan perbedaan pada bagian yang melakukan penggabungan list (return merge(left, right)).
Penggabungan list sendiri dilakukan dengan cukup sederhana dan gamblang, yaitu hanya membandingkan elemen-elemen dari dua buah list yang dikirimkan satu per satu, untuk kemudian disimpan ke dalam variabel result secara terurut. Untuk lebih jelasnya, mari kita coba bedah algoritma pada fungsi merge, langkah demi langkah.
Misalkan kita memanggil fungsi merge seperti berikut:
left = [3, 5]
right = [1, 4]
merge(left, right)
Note
Ingat bahwa list pada variabel left maupun right harus sudah terurut jika ukuran list lebih dari 1. Fungsi merge dengan argumen list berukuran \(>\) 1 hanya dipanggil dari hasil merge dua buah list berukuran satu dalam kasus merge_sort.
Jika kita mengikuti langkah demi langkah pada kode, maka pada setiap iterasi while kita akan mendapatkan nilai masing-masing variabel sebagai berikut:
# Awal fungsi
left = [3, 5]
right = [1, 4]
result = []

# Iterasi 1
left = [3, 5]
right = [4]
result = [1]

# Iterasi 2
left = [5]
right = [4]
result = [1, 3]

# Iterasi 3
left = [5]
right = []
result = [1, 3, 4]

# Iterasi 4
left = []
right = []
result = [1, 3, 4, 5]
Penggabungan seperti di atas dilakukan pada setiap submasalah yang telah dipecah oleh merge_sort, sampai kita mendapatkan sebuah list dengan ukuran yang sama pada list awal. Untuk mempermudah pengertian, gambar di bawah menunjukkan proses pemecahan dan penggabungan kembali dari merge sort:

Langkah Kerja Merge Sort
Proses divide terjadi ketika kotak dan panah berwarna merah, sementara conquer dan combine terjadi ketika kotak dan panah diberi warna biru. Proses conquer merupakan proses di mana kita mengurutkan elemen dalam list, dan combine adalah ketika kita menggabungkan hasil urutan dari list tersebut.
Contoh D&C 2: Binary Search
Binary search merupakan salah satu algoritma pencarian yang paling efisien, dengan kompleksitas \(O(\log n)\). Algoritma ini memanfaatkan teknik divide and conquer dengan memecah lingkup pencarian data menjadi setengahnya pada setiap kali divide. Kekurangan dari binary search yaitu bahwa algoritma ini hanya dapat digunakan pada sebuah data atau lsit yang telah terurut.
Langsung saja, implementasi binary search menggunakan python:
def binary_search(data, search_val, min_idx, max_idx):
if max_idx < min_idx:
print("%d not found in list"%search_val)
return -1

mid_idx = (min_idx + max_idx) // 2
if data[mid_idx] > search_val:
return binary_search(data, search_val, min_idx, mid_idx - 1)
elif data[mid_idx] < search_val:
return binary_search(data, search_val, mid_idx + 1, max_idx)
else:
print("%d found in index %d"%(search_val, mid_idx))
return mid_idx
Mari kita lihat cara kerja binary search. Misalkan kita diberikan data berupa list bilangan seperti berikut:
[1, 2, 4, 6, 7, 8, 9, 10]
dan diminta untuk mencari letak angka 2 pada list tersebut. Sebelum mulai menjalankan algoritma, pastinya kita harus mengetahui nilai-nilai awal terelbih dahulu. Adapun nilai awal yang dibutuhkan untuk fungsi binary_search adalah sebagai berikut:
data = [1, 2, 4, 6, 7, 8, 9, 10]
search_val = 2
min_idx = 0
max_idx = len(data) - 1 # 7
Nilai indeks minimal (batas awal pencarian) yang pertama tentunya adalah 0, dengan nilai maksimal (batas akhir pencarian) adalah ukuran dari list itu sendiri. Di langkah awal binary search, dilakukan perhitungan terhadap nilai tengah dari min_idx dan max_idx terlebih dahulu, untuk mendapatkan titik awal pencarian. Perhitungan nilai tengah dilakukan pada kode berikut:
mid_idx = (min_idx + max_idx) // 2
Setelah mendapatkan nilai tengah, kita lalu melakukan cek apakah nilai dari data pada indeks tersebut lebih besar atau lebih kecil dibandingkan nilai yang akan kita cari (2). Langkah pengecekan ini dilakukan pada perintah if berikut:
if data[mid_idx] > search_val:
# nilai lebih besar daripada 2
elif data[mid_idx] < search_val:
# nilai lebih kecil daripada 2
else:
# nilai adalah 2 (ditemukan)
Dalam kasus ini, nilai dari mid_idx adalah 3, dan karena data[3] berisi 6, maka kita akan melakukan pemotongan terhadap seluruh nilai pada data setelah 6, karena nilai tersebut sudah pasti tidak diperlukan lagi (ingat, data harus terurut pada binary search). Kita lalu memanggil fungsi binary_search lagi, kali ini dengan mencari hanya pada submasalah (list) berikut (perhatikan bagaimana pada pemanggilan binary_search yang kedua nilai max_idx kita ubah menjadi mid_idx - 1):
[1, 2, 4]
Dan dengan mengaplikasikan logika yang sama dengan tahap sebelumnya, kita akan langsung menemukan bilangan yang dicari.
Algoritma Greedy
Algoritma greedy merupakan jenis algoritma yang menggunakan pendekatan penyelesaian masalah dengan mencari nilai maksimum sementara pada setiap langkahnya. Nilai maksimum sementara ini dikenal dengan istilah local maximum. Pada kebanyakan kasus, algoritma greedy tidak akan menghasilkan solusi paling optimal, begitupun algoritma greedy biasanya memberikan solusi yang mendekati nilai optimum dalam waktu yang cukup cepat.
Sebagai contoh dari penyelesaian masalah dengan algoritma greedy, mari kita lihat sebuah masalah klasik yang sering dijumpai dalam kehidupan sehari-hari: mencari jarak terpendek dari peta. Misalkan kita ingin bergerak dari titik A ke titik B, dan kita telah menemukan beberapa jalur dari peta:

Jalur dari Titik A ke B
Dari peta yang ditampilkan di atas, dapat dilihat bahwa terdapat beberapa jalur dari titik A ke titik B. Sistem peta pada gambar secara otomatis telah memilih jalur terpendek (berwarna biru). Kita akan mencoba mencari jalur terpendek juga, dengan menggunakan algoritma greedy.
Langkah pertama yang harus kita lakukan tentunya adalah memilih struktur data yang tepat untuk digunakan dalam merepresentasikan peta. Jika dilihat kembali, sebuah peta seperti pada gambar di atas pada dasarnya hanya menunjukkan titik-titik yang saling berhubungan, dengan jarak tertentu pada masing-masing titik tersebut. Misalnya, peta di atas dapat direpresentasikan dengan titik-titik penghubung seperti berikut:

Graph Sederhana dari Titik A ke B
Dari gambar di atas, kita dapat melihat bagaimana sebuah peta jalur perjalanan dapat direpresentasikan dengan menggunakan graph, spesifiknya Directed Graph (graph berarah). Maka dari itu, untuk menyelesaikan permasalahan jarak terpendek ini kita akan menggunakan struktur data graph untuk merepresentasikan peta. Berikut adalah graph yang akan digunakan:

Graph Berarah dari Titik A ke B
Untuk mencari jarak terpendek dari A ke B, sebuah algoritma greedy akan menjalankan langkah-langkah seperti berikut:
Kunjungi satu titik pada graph, dan ambil seluruh titik yang dapat dikunjungi dari titik sekarang.
Cari local maximum ke titik selanjutnya.
Tandai graph sekarang sebagai graph yang telah dikunjungi, dan pindah ke local maximum yang telah ditentukan.
Kembali ke langkah 1 sampai titik tujuan didapatkan.
Jika mengapliikasikan langkah-langkah di atas pada graph A ke B sebelumnya maka kita akan mendapatkan pergerakan seperti berikut:
Mulai dari titik awal (A). Ambil seluruh titik yang dapat dikunjungi.

Langkah Pertama Greedy
Local maximum adalah ke C, karena jarak ke C adalah yang paling dekat.
Tandai A sebagai titik yang telah dikunjungi, dan pindah ke C.
Ambil seluruh titik yang dapat dikunjungi dari C.

Langkah Kedua Greedy
Local maximum adaah ke D, dengan jarak 6.
Tandai C sebagai titik yang telah dikunjungi, dan pindah ke D.

Langkah Ketiga Greedy
(Langkah selanjutnya diserahkan kepada pembaca sebagai latihan).
Dengan menggunakan algoritma greedy pada graph di atas, hasil akhir yang akan didapatkan sebagai jarak terpendek adalah A-C-D-E-F-B. Hasi jarak terpendek yang didapatkan ini tidak tepat dengan jarak terpendek yang sebenarnya (A-G-E-F-B). Algoritma greedy memang tidak selamanya memberikan solusi yang optimal, dikarenakan pencarian local maximum pada setiap langkahnya, tanpa memperhatikan solusi secara keseluruhan. Gambar berikut memperlihatkan bagaimana algoritma greedy dapat memberikan solusi yang kurang optimal:

Solusi Kurang Optimal dari Greedy
Tetapi ingat bahwa untuk kasus umum, kerap kali algoritma greedy memberikan hasil yang cukup baik dengan kompleksitas waktu yang cepat. Hal ini mengakibatkan algoritma greedy sering digunakan untuk menyelesaikan permasalahan kompleks yang memerlukan kecepatan jawaban, bukan solusi optimal, misalnya pada game.
Implementasi Algoritma Greedy
Untuk memperdalam pengertian algoritma greedy, kita akan mengimplementasikan algoritma yang telah dijelaskan pada bagian sebelumnya ke dalam kode program. Seperti biasa, contoh kode program akan diberikan dalam bahasa pemrograman python. Sebagai langkah awal, tentunya kita terlebih dahulu harus merepresentasikan graph. Pada implementasi yang kita lakukan, graph direpresentasikan dengan menggunakan dictionary di dalam dictionary, seperti berikut:
DAG = {'A': {'C': 4, 'G': 9},
'G': {'E': 6},
'C': {'D': 6, 'H': 12},
'D': {'E': 7},
'H': {'F': 15},
'E': {'F': 8},
'F': {'B': 5}}

# Hasil Representasi:
{'A': {'C': 4, 'G': 9},
'C': {'D': 6, 'H': 12},
'D': {'E': 7},
'E': {'F': 8},
'F': {'B': 5},
'G': {'E': 6},
'H': {'F': 15}}
Selanjutnya kita akan membuat fungsi yang mencari jarak terpendek dari graph yang dibangun, dengan menggunakan algoritma greedy. Definisi dari fungsi tersebut sangat sederhana, hanya sebuah fungsi yang mengambil graph, titik awal, dan titik akhir sebagai argumennya:
def shortest_path(graph, source, dest):
Jarak terpendek yang didapatkan akan dibangun langkah demi langkah, seperti pada algoritma greedy yang mengambil nilai local maximum pada setiap langkahnya. Untuk hal ini, tentunya kita akan perlu menyimpan jarak terpendek ke dalam sebuah variabel, dengan source sebagai isi awal variabel tersebut. Jarak terpendek kita simpan ke dalam sebuah list, untuk menyederhanakan proses penambahan nilai.
result = []
result.append(source)
Penelusuran graph sendiri akan kita lakukan melalui result, karena variabel ini merepresentasikan seluruh node yang telah kita kunjungi dari keseluruhan graph. Variabel result pada dasarnya merupakan hasil implementasi dari langkah 3 algoritma ("Tandai graph sekarang sebagai graph yang telah dikunjungi"). Titik awal dari rute tentunya secara otomatis ditandai sebagai node yang telah dikunjungi.
Selanjutnya, kita akan menelusuri graph sampai titik tujuan ditemukan, dengan menggunakan iterasi:
while dest not in result:
current_node = result[-1]
dengan mengambil node yang sekarang sedang dicari local maximum-nya dari isi terakhir result. Pencarian local maximum sendiri lebih memerlukan pengetahuan python daripada algoritma:
# Cari local maximum
local_max = min(graph[current_node].values())

# Ambil node dari local maximum,
# dan tambahkan ke result
# agar iterasi selanjutnya dimulai
# dari node sekarang.
for node, weight in graph[current_node].items():
if weight == local_max:
result.append(node)
Setelah seluruh graph ditelurusi sampai mendapatkan hasil, kita dapat mengembalikan result ke pemanggil fungsi:
return result
Keseluruhan fungsi yang dibangun adalah sebagai berikut:
def shortest_path(graph, source, dest):
result = []
result.append(source)

while dest not in result:
current_node = result[-1]

local_max = min(graph[current_node].values())
for node, weight in graph[current_node].items():
if weight == local_max:
result.append(node)

return result
Perlu diingat bahwa fungsi ini masih banyak memiliki kekurangan, misalnya tidak adanya penanganan kasus jika titik tujuan tidak ditemukan, atau jika terdapat node yang memiliki nilai negatif (bergerak balik). Penanganan hal-hal tersebut tidak dibuat karena fungsi hanya bertujuan untuk mengilustrasikan cara kerja algoritma greedy, bukan untuk digunakan pada aplikasi nyata.
Kesimpulan
Algoritma greedy merupakan algoritma yang besifat heuristik, mencari nilai maksimal sementara dengan harapan akan mendapatkan solusi yang cukup baik. Meskipun tidak selalu mendapatkan solusi terbaik (optimum), algoritma greedy umumnya memiliki kompleksitas waktu yang cukup baik, sehingga algoritma ini sering digunakan untuk kasus yang memerlukan solusi cepat meskipun tidak optimal seperti sistem real-time atau game.
Dari impementasi yang kita lakukan, dapat dilihat bagaimana algoritma greedy memiliki beberapa fungsionalitas dasar, yaitu:
Fungsi untuk melakukan penelusuran masalah.
Fungsi untuk memilih local maximum dari pilihan-pilihan yang ada tiap langkahnya.
Fungsi untuk mengisikan nilai local maximum ke solusi keseluruhan.
Fungsi yang menentukan apakah solusi telah didapatkan.
Tentunya fungsi-fungsi di atas juga dapat digabungkan atau dipecah lebih lanjut lagi, menyesuaikan dengan strategi greedy yang dikembangkan.
Dynamic Programming
Dynamic Programming (selanjutnya disebut "DP" saja) merupakan salah satu teknik perancangan algoritma yang dikembangkan untuk menyelesaikan permasalahan yang sangat kompleks dengan memecah permasalahan tersebut menjadi banyak sub-permasalahan. Perbedaan utama DP dengan Divide and Conquer (selanjutnya disebut "D&C") adalah pada DP kita menggunakan kembali hasil kalkulasi sub-masalah yang telah dilakukan sebelumnya. Apa artinya?
Untuk mempermudah penjelasan, mari kita selesaikan masalah sederhana yang telah kita bahas berkali-kali: perhitungan bilangan fibonacci. Algoritma untuk menyelesaikan perhitungan fibonacci secara naif adalah seperti berikut:
def fibonacci(n):
if n <= 2:
hasil = 1
else:
hasil = fibonacci(n - 1) + fibonacci(n - 2)

return hasil
Algoritma fibonacci sederhana seperti di atas dapat dikatakan sebagai algoritma D&C, karena kita membagikan perhitungan fibonacci ke dua fungsi fibonacci, sampai didapatkan nilai hasil terkecilnya. Pemanggilan fungsi fibonacci di atas dapat digambarkan seperti berikut:

Pemanggilan Fungsi Fibonacci
Perhatikan bagaimana \(f(n - 2)\) dan \(f(n - 3)\) dikalkulasikan sebanyak dua kali, dan semakin kita masuk ke dalam pohon pemanggilan, kita akan melihat semakin banyak fungsi-fungsi yang dipanggil berkali-kali. Pendekatan DP menghindari kalkulasi fungsi yang berulang kali seperti ini dengan melakukan memoization, yaitu menyimpan hasil kalkulasi fungsi tersebut dan menggunakan nilai yang disimpan ketika perhitungan yang sama dibutuhkan kembali. Dengan menyimpan hasil kalkulasi seperti ini, tentunya jumlah total langkah perhitungan yang harus dilakukan menjadi berkurang.
Misalnya, kita dapat menyimpan hasil kalkulasi dari fungsi fibonacci tersebut pada sebuah dictionary, seperti berikut:
memo = dict()

def fibonacci_dp(n):
if n in memo.keys():
return memo[n]
elif n <= 2:
hasil = 1
else:
hasil = fibonacci_dp(n - 1) + fibonacci_dp(n - 2)
memo[n] = hasil
return hasil
Dengan menyimpan hasil kalkulasi dari fungsi yang telah ada, maka proses pemanggilan fungsi akan menjadi seperti berikut:

Pemanggilan Fungsi Fibonacci Dynamic Programming
Seperti yang dapat dilihat, pohon pemanggilan fungsi terpotong setengahnya! Tentunya perhitungan fibonacci akan menjadi sangat efisien dengan menggunakan fungsi yang baru ini.
Pendekatan lain dalam menghitung fibonacci lagi, yang masih adalah DP, yaitu dengan menghitung nilai fibonacci dari bawah pohon (pada kode sebelumnya kita melakukan perhitungan dari atas pohon):
def fibonacci_dp_bu(n):
memo = dict()
for i in range(1, n + 1):
if i <= 2:
hasil = 1
else:
hasil = memo[i - 1] + memo[i - 2]
memo[i] = hasil
return memo[n]
Untuk melihat efek langsung dari ketiga fungsi tersebut, coba jalankan ketiga fungsi tersebut untuk n yang sama, dan lihat perbedaan waktu eksekusinya! Sebagai latihan tambahan, hitung juga kompleksitas dari ketiga fungsi perhitungan fibonacci tersebut.
Mari kita rangkum hal yang telah kita pelajari mengenai DP sejauh ini:
DP menyelesaikan masalah dengan memecah masalah menjadi sub-permasalahan.
Setiap solusi dari sub-permasalahan yang telah didapatkan disimpan untuk digunakan kembali jika terdapat sub-permasalahan yang sama. Teknik ini dikenal dengan nama memoization.
DP tidak harus menggunakan rekursif. Pemecahan sub-permasalahan juga dapat dilakukan dengan iterasi maupun kalkulasi sederhana.
Contoh Aplikasi Dynamic Programming: Text Justification
Kegunaan utama dari DP adalah untuk menyelesaikan masalah optimasi. Permasalahan optimasi artinya permasalahan yang mencari nilai terbaik, baik maksimal maupun minimal, dari sebuah solusi. Salah satu contoh paling praktis dalam penerapan DP model ini adalah algoritma untuk membuat teks rata tengah. Bagaimana cara kerja algoritma ini? Mari kita lihat masalah yang ingin diselesaikan terlebih dahulu.
Pada aplikasi pengolah kata seperti Microsoft Word, biasanya terdapat fitur untuk menentukan kemerataan teks yang ada pada paragraf, seperti yang nampak pada gambar di bawah:

Fitur Pemerataan Teks pada Microsoft Word
Bagaimana kita menentukan kemerataan teks? Secara umum, kemerataan sebuah teks ditentukan oleh beberapa hal berikut:
Ukuran dari halaman, yang tentunya akan mempengaruhi berapa lebar maksimal dari sebuah teks.
Ukuran setiap kata yang ada dalam teks, untuk menghitung berapa banyak kata yang dapat dimasukkan ke dalam satu baris teks.
Ukuran spasi dalam teks, seperti ukuran kata, untuk menghitung jumlah kata yang dapat dimasukkan ke dalam teks.
Ukuran karakter-karakter khusus seperti "!", "?", ",", .", dan lainnya. Meskipun biasanya berukuran kecil, karakter khusus tetap berperan dalam mengisi ruang tulisan.
Dengan melakukan kalkulasi sederhana dari teks, tentunya kita bisa saja melakukan pemerataan teks dengan mudah. Misalnya, untuk menghitung total teks yang dapat masuk ke dalam sebuah baris tulisan, kita dapat menggunakan persamaan berikut:
\[\text{ukuran halaman} \gets \text{total ukuran kata} + \text{total ukuran spasi} + \text{total ukuran simbol}\]
Sehingga untuk membuat sebuah teks menjadi rata penuh (justified) kita dapat memasukkan setiap kata, spasi, dan simbol satu demi satu sampai kita memenuhi sebuah baris. Jika kata selanjutnya tidak lagi memiliki ukuran yang cukup, maka kita dapat menambahkan spasi di tengah-tengah kata sebelumnya sampai baris penuh, dan lalu berpindah baris.
Secara sederhana, algoritma naif untuk melakukan rata penuh teks adalah seperti berikut:
Ambil satu elemen dalam teks, baik berupa kata, simbol, maupun spasi. Masukkan elemen ini ke dalam baris.
Hitung ukuran baris sekarang.
Ambil satu elemen lagi dalam teks, dan hitung ukurannya.
Tambahkan ukuran baris sekarang dengan ukuran elemen berikutnya. Hasil pengukuran ini selanjutnya akan disebut "Ukuran Baris Selanjutnya" atau UBS.
Cek nilai UBS:
Jika UBS masih lebih kecil dari lebar halaman, kembali ke langkah 1
Jika UBS sudah lebih dari lebar halaman:
Tambahkan spasi di antara setiap kata dalam baris sampai ukuran baris sama dengan lebar halaman.
Secara kasar, algoritma di atas dapat diimplementasikan seperti kode berikut (yang jelas tidak dapat dijalankan):
def naive_justify(text, page_size):
next = text.get_next()
total_size = 0
next_total_size = total_size + next.size()

lines = [[next]]
current_line = 0

while(!text.empty()):
while(next_total_size < page_size):
total_size = next_total_size
next = text.get_next()
lines[current_line].push(next)
next_total_size = total_size + next.size()

while total_size != page_size:
add_space(lines[current_line])

current_line = current_line + 1
Hasil algoritma di atas kurang optimal, karena ketika terdapat kata-kata yang panjang dalam sebuah kalimat, kita terpaksa harus memotong baris terlalu cepat, dan akhirnya menambahkan banyak spasi. Contoh eksekusi dari algoritma di atas dapat dilihat pada gambar berikut:

Hasil Algoritma Pemerataan Teks Sederhana
Perhatikan bagaimana teks "Dynamic Programming", "dikembangkan untuk", dan "memecah permasalahan" memiliki spasi yang sangat lebar. Menggunakan DP, kita dapat menghasilkan pemerataan teks yang lebih optimal.
Berdasarkan algoritma sebelumnya yang kita kembangkan, dapat dilihat bagaimana optimasi dari rata penuh sebuah teks terdapat pada kapan kita melakukan pergantian baris. Jika kita mengganti baris terlalu cepat (jumlah kata masih sedikit), maka secara otomatis kita harus menambahkan banyak spasi, yang menyebabkan teks tidak enak dilihat. Untuk mendapatkan jumlah kata yang optimal dalam sebuah baris, kita akan melakukan perhitungan tingkat "keburukan" sebuah kata dalam teks, jika kata tersebut dijadikan pengganti baris. Kita kemudian dapat mencari tingkat keburukan setiap kata yang ada dalam teks, dan mengambil kata yang memiliki tingkat keburukan terendah sebagai tanda berganti baris.
Pengukuran tingkat keburukan teks sendiri tentunya ditentukan oleh jumlah ruang kosong yang ada dari teks sampai ke ujung halaman. Misalnya, pada gambar di bawah kita dapat melihat contoh ruang kosong dari teks sampai ke ujung halaman:

Tingkat Keburukan Teks
Pada gambar di atas, blok berwarna merah berarti tingkat keburukannya tinggi, dan blok berwarna hijau berarti tingkat kebukurannya rendah. Untuk mendapatkan nilai keburukan yang paling kecil dalam sebuah teks, tentunya kita harus menghitung seluruh kombinasi nilai keburukan dari elemen-elemen yang ada dalam teks. Perhitungan kombinasi nilai keburukan ini tentunya merupakan masalah yang tepat untuk algoritma DP, karena setiap perhitungan nilai keburukan pada dasarnya adalah sebuah sub-masalah!
Jadi sekarang kita telah menemukan sub-masalahnya: mencari nilai keburukan dari sebuah elemen. Bagaimanakah kita dapat menggunakan teknik DP untuk menyelesaikan masalah ini? Ketika menghitung kombinasi dari nilai keburukan dari setiap elemen, secara tidak langsung kita akan membangun sebuah Directed Acyclic Graph, seperti yang tampak pada gambar berikut:

DAG dalam Teks
dengan setiap \(k\) merepresentasikan tingkat keburukan dari elemen tersebut. Menggunakan informasi tersebut, kita dapat mencari nilai minimal dari total seluruh nilai keburukan yang ada pada sebuah teks untuk mendapatkan titik penggantian baris yang paling tepat. Untuk merangkum, berikut adalah langkah-langkah untuk algoritma yang sedang kita kembangkan:
Ambil setiap elemen dari dalam teks.
Untuk setiap elemen yang ada, lakukan: 1. Hitung nilai keburukan dari elemen terhadap elemen-elemen lain dalam teks. 2. Hitung total nilai keburukan yang ada pada elemen yang sedang dicari.
Tentukan nilai keburukan minimum dari nilai keburukan seluruh elemen yang telah dihitung pada langkah 2.
Ambil elemen yang memiliki nilai keburukan minimum.
Ganti baris pada elemen dengan nilai keburukan minimum.
Perhitungan nilai keburukan sendiri dapat dilakukan dengan menggunakan rumus sederhana berikut:
\[\begin{split}keburukan(i, j) = \begin{cases} \text{ukuran baris} > \text{lebar halaman} & \infty \\ (\text{lebar halaman} - \text{ukuran baris})^3 \end{cases}\end{split}\]
dengan \(i\) dan \(j\) sebagai awal dan akhir dari kata yang ingin dihitung tingkat keburukannya. Jika dijadikan kode program, algoritma tersebut dapat dituliskan seperti berikut:
def length(word_lengths, i, j):
return sum(word_lengths[i- 1:j]) + j - i + 1


def break_line(text, L):
# wl = lengths of words
wl = [len(word) for word in text.split()]

# n = number of words in the text
n = len(wl)

# total badness of a text l1 ... li
m = dict()
m[0] = 0

s = dict()

for i in range(1, n + 1):
sums = dict()
k = i
while (length(wl, k, i) <= L and k > 0):
# badness calculation
sums[(L - length(wl, k, i))**3 + m[k - 1]] = k
k -= 1
m[i] = min(sums)
s[i] = sums[min(sums)]

return s
Perlu dicatat bahwa kode di atas belum mengikut sertakan spasi dalam perhitungan, dan juga belum membangun kembali baris-baris yang telah dipecah menjadi sebuah teks (paragraf).
Kesimpulan
Secara sederhana, teknik DP dapat dikatakan adalah sebuah teknik brute force yang pintar. Kita memecah-mecah masalah menjadi sub-masalah, dan menyelesaikan seluruh sub-masalah tersebut. Perbedaan utama dari DP dengan D&C adalah DP melakukan penyimpanan hasil penyelesaian sub-masalah sehingga kita tidak perlu menyelesaikan sub-masalah yang sama berulang kali.
Pengertian Algoritma dan Contoh Algoritma, Lengkap!
Pengertian Algoritma
Pengertian algoritma adalah suatu urutan dari beberapa langkah yang logis guna menyelesaikan masalah. Pada saat kita memiliki masalah, maka kita harus dapat untuk menyelesaikan masalah tersebut dengan menggunakan langkah-langkah yang logis. Contoh dari algoritma sederhana dalam kehidupan nyata adalah pada saat memasak air. Hal-hal yang perlu dilakukan untuk memasak air seperti berikut : siapkan panci, masukkan air secukupnya ke dalam panci, tutup panci tersebut, letakkan panci tersebut di atas kompor, hidupkan kompor dengan api sedang, apabila air sudah mendidih, matikan kompor, setelah itu angkat panci tersebut dari kompor. Langkah-langkah untuk memasak air tersebut merupakan algoritma memasak air. Sehingga memiliki urutan langkah-langkah yang logis.

Dalam ilmu matematika dan komputer, pengertian algoritma merupakan prosedur dari beberapa langkah demi langkah untuk penghitungan. Algoritma dipakai untuk penghitungan, penalaran otomatis, dan pemrosesan data. Pengertian algoritma ialah suatu metode yang efektif diekspresikan sebagai rangkaian yang terbatas dari beberapa instruksi yang telah dijelaskan dengan baik guna menghitung sebuah fungsi. Susunan algoritma dimulai dari kondisi awal dan input awal, instruksi tersebut mendeskripsikan komputasi yang apabila itu dieksekusi serta diproses dengan melewati urutan-urutan kondisi terbatas yang terdefinisi dengan baik, sehingga dapat menghasilkan output atau keluaran dan berhenti di kondisi akhir yang telah ditentukan.

Algoritma sangat diperlukan untuk mengolah data yang ada di komputer. Dalam sistem komputer, pengertian algoritma ialah logika yang dibuat dengan memakai software oleh para pembuat perangkat lunak untuk membuat software tersebut menjadi lebih bagus. Algoritma berbeda dengan Logaritma. Perlu diketahui juga bahwa logaritma adalah sebuah operasi di ilmu matematika guna menghitung kebalikan eksponen dari sebuah perpangkatan.

Kata Algoritma ditemukan oleh Abu Abdullah Muhammad Ibnu Musa Al-Khwarizmi, beliau merupakan matematikawan yang berasal dari Persia yang ditemukan pada Abad Ke 9. Dari masa ke masa, kata algoritma mulai berkembang di abad ke 18.

Untuk lebih jelasnya lagi, berikut salah satu contoh algoritma :
Algoritma untuk menghitung nilai x dari persamaan x = 17y + 9 :
1) Memulai
2) Menentukan nilai y
3) Menghitung nilai x = 17y + 9
4) Menyelesaikan
Bentuk Dasar Algoritma
Algoritma sendiri mempunyai tiga 3 bentuk dasar, antara lain :
Algoritma Sekuensial (Sequence Algorithm)
Sequence algorithm atau algoritma sekuensial merupakan algoritma yang langkah-langkahnya secara urut dari awal hingga akhir. Bentuk dari algoritma sekuensial ini salah satu contohnya seperti algoritma memasak air. Langkah demi langkah yang dijalankan harus urut dari atas sampai bawah.
Algoritma Perulangan (Looping Algorithm)
Looping algorithm atau algoritma perulangan merupakan suatu algoritma yang menjalankan beberapa langkah tertentu secara berulang-ulang atau looping. Pada masalah yang kita hadapi, ada pula sebuah langkah yang harus kita lakukan secara berulang-ulang. Contoh dari algoritma looping ini adalah algoritma menjemur pakaian:
1) Siapkan jemuran.
2) Ambil satu pakaian yang nantinya akan dijemur.
3) Peras pakaian tersebut terlebih dahulu.
4) Letakkan pakaian tersebut pada tiang jemuran.
5) Ulangi langkah dari 2 sampai 4 hingga pakaian habis.
Dari algoritma di atas, dapat diketahui bahwa dari langkah 2 sampai 4 harus dilakukan secara berulang-ulang hingga pakaian habis.
Algoritma Percabangan atau Bersyarat (Conditional Algorithm)
Conditional algorithm atau algoritma bersyarat merupakan algoritma yang menjalankan langkah berikutnya apabila terdapat syarat yang sudah dapat dipenuhi. Berikut salah satu contoh dari algoritma bersyarat :
1) Siapkan panci.
2) Masukkan air secukupnya ke dalam panci.
3) tutup panci tersebut.
4) letakkan panci tersebut di atas kompor.
5) Hidupkan kompor.
6) Apabila air sudah mendidih, lalu matikan kompor.
7) Angkat panci tersebut dari kompor.
Algoritma bersyarat atau contional algorithm terdapat pada langkah ke 6. Apabila air sudah mendidih, lalu matikan kompor. Sehingga apabila air tersebut belum mendidih, maka kompor tidak dimatikan.

Merancang Algoritma yang Baik
Menurut Donald E. Knuth, dari pengertian algoritma diatas dapat diketahui bahwa sebuah algoritma yang baik yaitu algoritma yang mempunyai kriteria sebagai berikut :
Masukan (Input)
Algoritma mempunyai input 0 (nol) atau lebih
Keluaran (Output)
Algoritma harus menghasilkan atau mengeluarkan minimal 1 output.
Terbatas (Finite)
Algoritma harus berhenti setelah melakukan langkah-langkah yang diperlukan.
Pasti (Definite)
Algoritma harus jelas kapan dimulai dan berakhir. Tujuan dari algoritma harus jelas. Setiap langkah-langkah harus dijelaskan dengan jelas.
Efisien
Membuat sebuah algoritma haruslah efisien. Adanya langkah seperti mencari hasil 1 + 0 tidak efisien. Hal ini karena bilangan apapun itu jika ditambah dengan nol maka hasilnya ialah bilangan itu sendiri. Sehingga adanya langkah seperti itu tidak perlu dimasukkan ke dalam sebuah algoritma.


Algoritma dapat disajikan ke dalam 2 bentuk, yaitu bentuk tulisan atau bahasa dan bentuk gambar. Penyajian algoritma dalam bentuk bahasa atau tulisan harus memakai sebuah bahasa yang dapat untuk dimengerti manusia dalam membuat langkah-langkah dari algoritma itu sendiri. Penyajian algoritma dalam bentuk tulisan/bahasa dapat dilakukan dengan memakai pseudocode. Pseudocode berasal dari "pseudo" aritnya "menyerupai atau mirip" dan "code" yaitu "kode program". Contoh dari beberapa bahasa pemrograman yang sering digunakan untuk menyatakan pseudocode antara lain : pascal, BASIC, Pascal, C, dan lain sebagainya. Terdapat juga penyajian algoritma yang dalam bentuk gambar disebut flow chart.
Klasifikasi Algoritma
Salah satu cara untuk mengklasifikasikan algoritma yaitu dengan menggunakan cara implementasi.
Rekursi atau iterasi
Algoritma rekursi ialah suatu algoritma yang memanggil dirinya sendiri secara berulang kali (looping) hingga pada kondisi tertentu dapat tercapai. Rekursi merupakan suatu metode umum dalam pemrograman fungsional. Algoritma iteratif memakai konstruksi berulang seperti pada pengulangan dan terkadang terdapat struktur data tambahan. Beberapa permasalahan secara alami dapat cocok dengan 1 implementasi atau yang lainnya. Contohnya : Menara Hanoi yang dikenal dengan implementasi rekursif. Pada setiap versi rekursif mempunyai adanya kesamaan (bisa lebih ataupun kurang kompleks) dengan versi iteratif, ataupun sebaliknya.
Logical
Algoritma dapat dilihat sebagai sebuah logika deduksi terkontrol. Pernyataan ini dapat diekspresikan sebagai: Algoritma = kontrol + logika. Komponen logika yang mengekspresikan aksioma dapat digunakan dalam komputasi serta komponen kontrol dalam menentukan cara-cara deduksi yang digunakan pada aksioma. Hal tersebut adalah dasar dari paradigma pemrograman logika. Dalam pemrograman, logika murni komponen kontrol ialah tetap serta algoritma yang ditentukan dengan memberikan hanya ada komponen logikanya. Daya tarik dari pendekatan logical ialah semantik elegan, sebuah perubahan yang ada dalam aksioma mempunyai perubahan dalam algoritma.
Serial, paralel atau terdistribusi
Pada umumnya, suatu algoritma menjalankan satu instruksi algoritma setiap waktu. Komputer tersebut dapat disebut dengan komputer serial. Rancangan algoritma yang digunakan bagi lingkungan tersebut ialah algoritma serial, terbalik dengan algoritma terdistribusi atau algoritma paralel. Algoritma paralel menggunakan arsitektur komputer yang mana terdapat prosesor-prosesor dapat mengerjakan masalah pada waktu yang sama. Sedangkan algoritma terdistribusi menggunakan banyak mesin yang terhubung ke jaringan. Algoritma terdistribusi atau paralel membagi permasalahan ke banyak submasalah simetris maupun asimetris dan mengumpulkan hasil yang didapat kembali. Konsumsi dari sumber pada algoritma tersebut tidak hanya ada perputaran prosesor tapi juga terdapat daya komunikasi antara prosesor. Algoritma pengurutan dapat untuk diparalelkan secara efisien, namun terdapat biaya komunikasi yang sangat mahal. Algoritma iteratif pada umumnya dapat untuk diparalelkan. Ada juga permasalah yang tidak ada algoritma paralelnya, disebut dengan permasalahan serial lahiriah.
Deterministik atau non-deterministik
Terdapat juga algoritma determministik dan non-determenistik. Algoritma deterministik dapat menyelesaikan masalah-masalah dengan keputusan tepat disetiap langkah-langkah dari sebuah algoritma. Algoritma non-deterministik dapat menyelesaikan masalah-masalah lewat adanya penerkaan walaupun penerkaan tersebut pada umumnya lebih akurat dengan memakai heuristik.
Tepat atau perkiraan
Jika terdapat banyak algoritma dapat sampai ke solusi yang tepat, ada juga algoritma perkiraan yang mencari perkiraan terdekat dengan solusi benarnya. Perkiraan tersebut dapat memakai strategi deterministik ataupun acak. Algoritma yang seperti itu dapat mempunyai nilai lebih untuk banyak permasalahan yang sulit.
Algoritma quantum
Berjalan pada model realistik dari komputasi quantum. Istilah tersebut pada umumnya dipakai bagi algoritma yang pada dasarnya quantum, ataupun memakai fitur-fitur penting dari komputasi quantum seperti belitan quantum atau superposisi quantum.

Contoh Algoritma
Menentukan Apakah Bilangan Tersebut Ganjil atau Genap
Terdapat bilangan yang bernama bilang bulat yaitu 0, 1, -1, 2, dst serta bilangan asli 1, 2, 3, 4, 5, dst. Kedua jenis bilangan tersebut sering digunakan dalam berhitung. Himpunan bilangan-bilangan bulat dalam buku teks aljabar pada umumnya dinyatakan dengan lambang "Z" dan himpunan bilangan-bilangan asli dinyatakan dengan lambang "N". Algoritma guna menentukan apakah bilangan tersebut ganjil atau genap dapat disajikan dengan flowchart seperti dibawah ini :

Bilangan genap merupakan sebuah bilangan bulat yang akan habis atau tidak memiliki sisa jika dibagi 2 (dua). Bilangan ganjil merupakan sebuah bilangan bulat yang tidak akan habis apabila dibagi 2 (dua).
Menghitung Keliling dan Luas Lingkaran
Lingkaran merupakan suatu himpunan dari semua titik-titik pada bidang dalam jarak yang tertentu dan disebut dengan jari-jari dari titik tertentu dan dapat disebut titik pusat. Lingkaran merupakan contoh dari kurva tertutup sederhana, lingkaran membagi bidang menjadi bagian luar dan dalam. Algoritma menghitung keliling serta luas lingkaran dapat disajikan dengan flowchart seperti dibawah ini :

Menampilkan Bilangan Ganjil Diantara 10 sampai 30
Bilangan ganjil yang terletak diantara 10 dan 30 11,13,15, dan seterusnya. Namun, yang akan ditampilkan kecuali bilangan 21 dan 27. Jadi output yang diharapkan dari algoritma tersebut adalah bilangan ganjil 10 sampai 30 kecuali bilangan 21 dan 27. Algoritma untuk menampilkan bilangan ganjil antara 10 hingga 30 kecuali bilangan 21 dan 27 disajikan dengan flowchart dibawah ini :

Algoritma tahun Kabisat
Terdapat juga algoritma tahun kabisat. Tahun kabisat merupakan sebuah tahun yang memiliki tambahan 1 hari dan bertujuan agar kalender dapat sinkron dengan musim tahunan dan keadaan astronomi. Bulan Februari memiliki 29 hari pada saat tahun kabisat. Tahun yang dapat untuk dibagi dengan 4 adalah tahun kabisat. Algoritma guna menentukan tahun kabisat jika disajikan dengan flowchart seperti dibawah ini :

Menampilkan Bilangan Genap Mullai dari Angka 2 sampai n, Kecuali Bilangan Genap yang Kelipatan 4
Bilangan genap merupakan sebuah bilangan-bilangan bulat yang habis jika dibagi 2. Deret yang ditampilkan dari algoritma kali ini merupakan deret dari bilangan genap dari 2 hingga ke n kecuali bilangan yang merupakan kelipatan 4. Algoritma tersebut dapat digambarkan dengan flowchart seperti dibawah ini :

Menghitung Harga yang Dibayar Setelah Mendapatkan Sebuah Diskon
Ada juga algoritma yang dapat menghitung jumlah dari biaya yang harus dibayar oleh sang pembeli setelah mendapatkan sebuah diskon 10% dengan syarat jumlah dari total pembelian tersebut Rp.1.500.000,- Algoritma guna menghitung besaran biaya tersebut dapat digambarkan dengan flowchart seperti dibawah ini :

Jumlah barang memiliki sifat yang dinamik sesuai dengan input atau masukkan dari user. Apabila jumlah total dari harga tersebut kurang 1500000 maka tidak mendapatkan sebuah diskon.
Mencari Maks dan Min dari suatu Deret Bilangan
Terdapat juga sebuah algoritma guna mencari nilai maks serta min dari suatu n deret bilangan yang dimasukkan atau diinput oleh user. Algoritma tersebut dapat disajikan dengan flowchart seperti dibawah ini :

Kalkulator Sederhana dari 2 Bilangan
Terdapat sebuah algoritma sebagai kalkulator sederhana untuk operasi penjumlahan, perkalian, pembagian, dan pengurangan. Kalkulator sederhana ini hanya dapat melakukan perhitungan dari 2 bilangan yang diinput oleh user. Algoritma guna menghitung 2 bilangan dapat digambarkan dengan flowchart seperti dibawah ini :

Menghitung Beberapa Angka dari Suatu Bilangan
Pada flowchart kali ini mengenai sebuah algoritma untuk menghitung beberapa angka dari suatu bilangan yang dimasukkan atau diinput oleh user. Berikut flowchart algoritma tersebut :

Membalik Sebuah Kalimat
Seperti yang kita ketahui sebelumnya tentang pengertian algoritma, bahwa algoritma juga dapat untuk menampilkan sebuah kalimat namun dengan urutan yang terbalik. Misalkan "woocara" dibalik menjadi "aracoow". Struktur data yang digunakan ialah Stack. Untuk membalik sebuah bilangan, huruf dari kalimat kita input dalam stack dengan menggunakan metode Push. Setelah stack tersebut sudah terisi, maka output kembali dengan memakai metode Pop. Pada algoritma membalik sebuah kalimat, adanya penggunaan struktur data stack diimplementasikan ke array. Dalam implementasinya ke array tersebut, kita harus terlebih dahulu menyiapkan sebuah array dengan memiliki panjang yang sama dengan jumlah huruf yang ada dalam kalimat yang akan dibalik tersebut. Pada gambar flowchart dibawah ini, terdapat tiap huruf dari kalimat yang diinput pada array dengan index ke-0 hingga ke-n dengan memakai metode push.

Kemudian huruf tersebut akan mengeluarkan kata mulai dari index ke-n hingga index ke-0.

Read more: http://woocara.blogspot.com/2016/02/pengertian-algoritma-contoh-algoritma.html#ixzz4Glb4VrNO