Presentasi sedang didownload. Silahkan tunggu

Presentasi sedang didownload. Silahkan tunggu

Kompleksitas Algoritma Mengukur efisiensi sebuah Algoritma.

Presentasi serupa


Presentasi berjudul: "Kompleksitas Algoritma Mengukur efisiensi sebuah Algoritma."— Transcript presentasi:

1 Kompleksitas Algoritma Mengukur efisiensi sebuah Algoritma

2 Contoh : algoritma untuk menghitung perpangkatan dua bilangan f(x,y)= x y def pangkat(x, y): hasil = 1 for i in range(0, y): hasil = x * hasil return hasil

3 Pada dasarnya yang kita lakukan pada kode di atas adalah 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

4 YProsesJml Langkah

5 Semakin besar nilai Y, jml eksekusi semakin besar, jadi bayangkan jika jml eksekusi yg diperlukan Y 2 YJml Langkah (Y)Jml Langkah (Y 2)

6

7 Notasi Asimtotik Perhitungan pertumbuhan fungsi seperti yang kita lakukan sebelumnya sangat krusial dalam menghitung efisiensi sebuah algoritma Penulisan fungsi pertumbuhan dilakukan dengan menggunakan notasi asimtotik Big-O dipilih karena merupakan notasi yang paling populer dan paling banyak digunakan pada kalangan peneliti ilmu komputer

8 Fungsi Big-ONama O(1)Konstan O(Log n)Logaritmik O(n)Linier O(n log n)n log n O(n 2 )Kuadratik O(n m )Polinomial O(n!)Faktorial

9 O(1), 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

10 void add_list(node *anchor, node *new_list) { new_list->next = anchor->next; anchor->next = new_list; } untuk menambahkan elemen baru ke dalam linked list tidak memerlukan perulangan, percabangan, ataupun banyak langkah

11

12 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

13 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

15 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 adalah seperti berikut: f(n)=2+7(jumlah perulangan)

16 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 dipe ngaruhi secara langsung oleh i, sehingga dapat dikatakan bahwa kunci dari berhentinya perulangan ada pada i

17 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):

18 Sejauh ini kita memiliki model matematika seperti berikut (konstanta 2 dihilangkan karena tidak berpengaruh): Jika diturunkan lebih lanjut

19 kita ketahui kondisi dari pemberhentian perulangan adalah ketika sisa elemen list adalah 1 Artinya : Sehingga dapat dikatakan bahwa binary search memiliki kompleksitas Atau sederhananya

20

21 O(n): Kompleksitas Linear Algoritma dengan kompleksitas linear bertumbuh selaras dengan pertumbuhan ukuran data. Maka algoritma ini memerlukan 10 langkah untuk menyelesaikan kalkulasi data berukuran 10, dan ia akan memerlukan 100 langkah untuk data berukuran 100

22 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

23 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

24 Dengan menggunakan cara perhitungan yang sama pada perhitungan pangkat, kita bisa mendapatkan jumlah eksekusi kode seperti berikut (dengan asumsi n = len(lst)): Sehingga nilai kompleksitas dari linear search adalah (5 + n) Atau ditulis O(n)

25

26 O(n log n) Algoritma dgn kompleksitas (n log n) memiliki cara perhitungan yang sangat mirip dengan algoritma (log n). Pada dasarnya algoritma Kelas ini merupakan algoritma logn yang Dijalankan sebanyak n kali.

27 Contoh kasus misalkan kita diminta untuk mencari sepasang bilangan di dalam sebuah list yang jika ditambahkan akan bernilai 0. Asumsikan list yang diberikan sudah terurut.

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

29 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")

30 Perhatikan bagaimana kita melakukan binary search sebanyak n kali, sehingga secara sederhana kompleksitas yang akan kita dapatkan adalah n ∗ log n=n log n.

31

32 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

33 def kali(a, b): res = 0 for i in range(a): for j in range(b): res += 1 return res

34 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:

35 Total langkah karena pada setiap iterasi kita harus menjalankan kode for i in range(b), maka dapat dikatakan kompleksitas dari kode di atas adalah a * b, Jika harga a = b maka kompleksitasnya adalah a 2 Dengan bentuk umum n m dengan m=2

36

37 Perbandingan Pertumbuhan Seluruh Kompleksitas n!2n2n n2n2 n log n n log n

38 Kesimpulan Pengembangan algoritma idealnya diusahakan mendapatkan kompleksitas O(1) atau O(logn). Tetapi 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.


Download ppt "Kompleksitas Algoritma Mengukur efisiensi sebuah Algoritma."

Presentasi serupa


Iklan oleh Google