-------------- Big OH PENJELASAN 1 --------------

Ok sekarang kita bahas sesuatu yang seharusnya setidaknya dimengerti oleh

programmer manapun :-?... (well gak harus, tapi ini lumayan penting menurut aku).

Yaitu Big O Notation, contohnya kayak gini :

O(1)
O(N)
O(N^2)
O(N^3)
O(sqrt(N))
O(log N)
O(N log N)
O(N!)
O(2^N)

Dan pertanyaannya adalah itu apaan?

Jadi suatu algoritma biasanya kompleksitasnya dinilai dengan Big O Notation,

kompleksitas itu bisa dibedain jadi time complexity (berapa lama algo itu jalan),
dan space complexity (berapa banyak memori yang bakal dipake oleh algo itu).

Aku bakal jelasin di time complexity aja seh, karena kalau udah ngerti itu
maksudnya apaan, bisa langsung dianalogiin untuk space complexity.

Jadi dalam suatu algo itu biasanya kita dikasih satu set data, kita bisa bilang
banyaknya data itu adalah N.

Jadi kalau algo kita O(1) artinya seberapa besar data yang dikasih waktu yang
diperlukan algo kita itu gak bergantung besarnya data, misalnya data sebanyak 10
biji diselesaikan dalam 1 detik, nah data yang 1000 biji juga selese dalam 1 detik.

Kalau O(N) artinya waktu yang diperlukan itu sebanding (berbanding lurus) dengan
banyaknya data, artinya misal data sebanyak 10 biji diselesaikan dalam 1 detik,
maka data 1000 biji diselesaikan dalam 100 detik. (data menjadi gede 100 kali,
waktu diperlukan menjadi gede 100 kali juga).

Dan kalau O(N^2) artinya waktu yang diperlukan itu berbanding kuadrat dengan
banyaknya data, artinya misal data sebanyak 10 biji itu selese dalam 1 detik, maka
data 1000 biji itu selese dalam 10000 detik. (data gede 100 kali, waktu jadi
100*100 = 10000 kali!).

Jadi biasanya waktu itu dihitung dari berapa banyak jumlah operasi yang dilakukan
algoritma itu. Untuk operasi sederhana, seperti penjumlahan, perkalian, dsb itu
dianggap satu operasi.

Misalnya ada algoritma ini

a = b + c;

Artinya ini algo kompleksitasnya O(1);

Dan kalau ini

a = b + c;
d = e + f;

Ini kompleksitasnya O(2)? Bukan ini masih tetep O(1). Tapi... tapi kan... yang algo
yang kedua pasti dua kali lebih lambat dari algo pertama, yups jawabannya iya. Tapi
kan kompleksitas itu dihitung berbanding dengan jumlah data, bukan lamanya :-?...
*well aku kayaknya jelek menjelaskannya*.

Ok lanjut dulu deh... kalau loop sederhana seperti ini

for(int i=0; i<N; i++)
{
a++;
}

Untuk data sebesar N, dia melakukan operasi sebanyak N kali, sehingga

kompleksitasnya O(N).

Dan untuk kasus ini

for(int i=0; i<N; i++)
{
a++;
b++;
}

Well banyak operasi di dalam loop yang dilakukan seh 2*N kali (gak termasuk
menambahkan i dan ngecek2 i<N), tapi kompleksitasnya tetep O(N).

Jadi bisa dibilang dalam Big O Notation konstanta seperti 2 pada O(2N) itu bisa
dihilangkan menjadi O(N), karena itu sama aja.

Dalam Big O Notation kita lebih memperhatikan bagaimana besarnya data itu
mempengaruhi kompleksitasnya dibandingkan seberapa banyak operasi yang sebenarnya
dijalankan.

Trus, untuk O(N^2), bisa dikira2 gini contohnya

for(int j=0; j<N; j++)
{
for(int i=0; i<N; i++)
{
a = max(a, i*j);
}
}
Untuk data sebesar N, banyaknya operasi yang dijalankan yaitu N*N, karena for yang
terluar ngeloop sebanyak N kali loop dalam yang ngeloop N kali.
Dan hal ini sama dengan O(N^3).

Dan coba tebak kompleksitas untuk kode berikut

for(int j=0; j<M; j++)
{
for(int i=0; i<N; i++)
{
a = max(a, i*j);
}
}
Ok, pasti bisa nebak kan kalau ini kompleksitasnya O(NM).

Ok sekarang yang lumayan agak rumit.

for(int j=0; j<N; j++)
{
for(int i=0; i<=j; i++)
{
a = max(a, i*j);
}
}
Well kompleksitasnya apaan ya? Kalau dilihat jumlah operasinya, misalkan N = 10,
maka jumlah operasinya ada sebanyak 1+2+3+...+10 = 55. Artinya jumlah operasinya
itu N*(N+1)/2 kan? Tapi ini bisa dijaddiin (N^2 + N)/2, artinya kompleksitasnya
O(1/2 * (N^2 + N)), tapi kan konstanta harus dihilangin, jadi O(N^2 + N).
Nah sampe sini, terserah seh mau gimana, tapi biasanya orang2 memilih untuk
menghilangkan N karena N^2 jauh lebih signifikan ngaruhnya dari N, jadi bisa
dibilang kompleksitas algo di atas itu O(N^2).
Again N^2 itu bukan berapa banyak operasi yang dilakuin, tetapi proporsi
kompleksitas terhadap banyaknya data.

Cara lain untuk menentukannya adalah biasanya orang cari worstcase dari loopnya,
jadi untuk loop terluar udah pasti ngeloop sebanyak N, dan loop yang didalam itu
berdasarkan j, nah kita cari worstcase yang bisa j hasilkan yaitu N, jadi O(N*N) =
O(N^2).

Well, ada juga yang lebih aneh dan susah dihitung kompleksitasnya, menghitung
kompleksitas tidak hanya sebatas for dan kali - kali doang, ada yang lebih
kompleks.
Misalnya ini
var x = N;
while(x > 1)
{
x = x /2;
}
Well berapa kompleksitasnya?
Kalau kita ngitung dari banyak operasi yang dilakukan, misalkan N = 10, maka tiap
loop akan mengubah x menjadi 5, 2, 1, artinya ada sebanyak 3 operasi. Kalau N = 20,
maka nanti akan menjadi 10, 5, 2, 1, ada sebanyak 4 operasi. N = 30, maka akan
menjadi 15, 7, 3, 1, masih 4. Kalau N = 100, maka akan menjadi 50, 25, 12, 6, 3, 1,
ada 6 operasi. Padahal N berubah dari 10 menjadi 100 (10 kali), tetapi jumlah
operasinya hanya menjadi 2 kali lebih banyak doang. Tentu ini bukan linear O(N),
jadi apa? Ok contoh lagi, N = 1000, maka akan menjadi 500, 250, 125, 62, 31, 15, 7,
3, 1, banyak operasi 9, padahal dari 10 menjadi 1000 itu 100 kali, tetapi banyak
operasinya hanya dari 3 menjadi 9, cuman 3 kali doang.

Jadi caranya untuk mengira2 adalah kira2 artinya kita membagi N dengan 2 pangkat D,
dimana D adalah banyaknya operasi supaya N/(2^D) = 1.
Artinya Nx = 2^D
Yang artinya juga D = 2log(N)
Jadi banyaknya operasi itu 2log(N), jadi kompleksitasnya O(2log(N)), tapi karena
2log(N) itu sama dengan log(N)/log(2), dan log(2) itu konstan, maka bisa dibuang
dan untuk simpelnya cuman ditulis O(log N).

Jadi intinya nyari kompleksitas kadang2 bisa gampang banget, kadang2 bisa belibet
banget, dan kadang2 kita buat algo dan kita gak tau kompleksitas algo kita karena
terlalu belibet LOL.
Sebenernya kompleksitas dalam Big O Notation ini lebih make sense kalau di plotting
ke graph, dengan sumbu x adalah banyak data, dan sumbu y untuk banyaknya operasi
yang dijalankan.
Dan kompleksitas adalah bentuk dari grafiknya.
Untuk O(1), grafik akan lurus secara horizontal.
Untuk O(N), grafik akan miring lurus ke kanan atas.
Untuk O(N^2), grafik akan membentuk grafik kuadrat, dimana ada lengkungan di
sebelah kanan bawah
Untuk O(N^3), grafik mirip dengan O(N^2) dengan lengkungan yang lebih tajam
Untuk O(sqrt(N)), grafik akan melengkung di kiri atas, sehingga semakin besar N,
grafik semakin mendatar.
Untuk O(log N), grafik akan melengkung di kiri atas juga tetapi cepat semakin
mendatar grafiknya.
Untuk O(2^N), grafiknya akan menjijikan langsung menuju ke atas
Untuk O(N!), grafiknya akan lebih menjijikan daripada 2^N
Untuk O(N^N), grafiknya akan kelihatan, well, mending jangan dilihat bisa kena
serangan jantung
Untuk lebih jelasnya aku dah ngegoogling supaya lebih make sense maksudnya...

Mungkin sementara ini dulu, takut dah kepanjangan, ini cuman gambaran kasar apa itu
Big O Notation sama kompleksitas.
Artikel ini gak sampai sini... Ini belum berakhir!!!
Jangan kamu kira kamu sudah menang, aku bakal kembali!!! *niru pelem2...

Ciao~...

-------------- Big OH PENJELASAN 1 --------------

-------------- Big OH PENJELASAN 2 --------------

Penggunaan Notasi Big-O Untuk Menganalisa Efisiensi Algoritma

Materi Semester 1 Makul Grenn Computing, dari pada nganggur didalam laptop

Penerapan Big O Notation atau Notasi O Besar untuk menganalisa efisiensi suatu
algoritma. Notasi O Besar biasa disebut juga Notasi Landau (Landau Notation) atau
Notasi Asimptotik (Asymptotic Notation) adalah notasi matematika yang digunakan
untuk menggambarkan sifat suatu fungsi asimptotik. Hal ini dilakukan untuk
mengamati sifat/kecenderungan suatu fungsi untuk masukan (input) yang sangat
besar/sangat kecil dengan cara yang simpel namun teliti sehingga dapat dilakukan
perbandingan dengan fungsi-fungsi yang lain Lebih jauh lagi, simbol O digunakan
untuk mengambarkan sebuah batas atas dari asimptotik suatu jarak/ukuran dari sebuah
fungsi untuk fungsi yang lebih simpel. Terdapat juga simbol-simbol seperti o, O,?,
dan T untuk batas-batas atas, bawah, dan rata-rata. Aplikasinya terdapat pada dua
area: dalam matematika, notasi ini digunakan untuk mengetahui karakteristik dari
syarat sisa untuk wilayah tak-hingga yang terpotong, terutama seri asimptotik.
Dalam computer science,notasi ini digunakan untuk menganalisa kompleksitas dari
suatu algoritma. Biasanya, notasi O besar digunakan untuk menggambarkan batas-batas
asimptotik. Namun batas asimptotik tersebut lebih umum dan tepat dinotasikan simbol
dengan T (theta besar) seperti akan dijelaskan dibawah ini.

Notasi diperkenalkan pertama kali di Jerman, oleh seorang number theorist Paul
Bachmann pada tahun 1894, pada edisi kedua dari bukunya yang berjudul Analytische
Zahlentheorie (analitik teori bilangan), dari edisi pertama yang (belum membahas
notasi O besar) yang diterbitkan pada 1892. Notasi ini menjadi populer oleh number
theorist Jerman yang lain, Edmund Landau, sehingga terkadang notasi ini disebut
Notasi Landau. O Besar adalah singkatan dari order of dalam bahasa Inggris, yang
sebenarnya adalah lambang Omicron besar, belakangan digunakan huruf latin dengan
bentuk yang identik yaitu huruf O besar, bukan 0(bilangan nol).

Kompleksitas Algoritma
Sebuah pertanyaan yang sering muncul adalah Seberapa efisienkah suatu algoritma
atau potongan kode? Efisiensi tergantung dari beberapa hal, diantaranya:

Kinerja CPU
Kinerja Memori
Kinerja Disk
Kinerja Jaringan
Semua aspek tersebut sangat penting, tapi disini akan membahas mengenai poin
pertama, yaitu CPU.

Berhati-hatilah ketika membandingkan antara

1. Performa: Berapa banyak waktu / memori / disk yang digunakan ketika program
berjalan. Tergantung dari mesin, compiler, dan kode.

Kompleksitas: Apa yang akan terjadi ketika ukuran masalah semakin besar.
Kompleksitas memengaruhi performa, namun tidak sebaliknya. Waktu yang diperlukan
untuk melakukan suatu baris kode / algoritma sebanding dengan operasi dasar yang
dilakukan.
Beberapa algoritma melakukan jumlah operasi yang sama dalam setiap kali
pemanggilannya. Algoritma seperti ini dikatakan memerlukan waktu yang konstan.
Beberapa algoritma lain melakukan jumlah operasi yang berbeda, tergantung dari
jumlah masukan pada parameter-nya. Misalnya, algoritma pemanggilan berurutan
(sequence), jumlah operasi yang dilakukan tergantung dari jumlah pemanggilan.
Parameter yang nilainya memengaruhi jumlah operasi yang dilakukan disebut problem
size atau input size. Ketika kita mengukur kompleksitas suatu algoritma, kita bukan
memerlukan jumlah operasi yang tepat, kita memerlukan bagaimana hubungan antara
jumlah operasi tersebut dengan ukuran masalah (problem size). Jika problem size-nya
double, apakah jumlah operasi akan tetap dua kali lipat? Ataukah bekembang dengan
cara tertentu? Untuk algoritma yang memerlukan waktu yang konstan, melipatgandakan
ukuran masalah tidak memengaruhi jumlah operasi yang dilakukan. Lebih jauh lagi,
biasanya kita tertarik dengan worst case, atau kasus terburuk; yaitu jumlah operasi
terbanyak yang mungkin dilakukan sebuah algoritma untuk ukuran masalah yang
diberikan (selain itu, terdapat juga kasus rata-rata average case dan kasus
terbaik best case-).

Big O Notation
Terdapat dua macam penggunaan notasi ini:

Asimptotik Tak Hingga (Infinite Asymptotik) dan Asimptotik Sangat Kecil

(Inifinitesimal Asymptotik). Perbedaan keduanya hanya terdapat pada aplikasi, bukan
pada konsep dasarnya. Definsi umum dari O Besar adalah sama untuk kedua kasus,
namun dengan batasbatas (limits) yang berbeda untuk argumen fungsi-nya.

Infinite Asymptotic

Notasi O Besar sangat berguna untuk mengnalisa efisiensi suatu algoritma. Misalnya,
waktu yang diperlukan untuk menyelesaikan sebuah masalah dengan parameter n bisa
jadi T(n) = 4n2 2n + 2

Semakin n bertambah besar, suku n2 akan mendominasi pertumbuhan, sehingga suku-suku

yang lain dapat diabaikan sebagai perumpamaan, jika n = 500, suku 4n2 akan 1000
kali lebih besar daripada suku 2n, sehingga mengabaikan suku-suku yang lebih kecil
tidak akan memberikan efek yang cukup signifikan. Lebih jauh lagi, koefisien dari
suku tersebut menjadi tidak relevan / dapat diabaikan. Misalnya ekspresi yang
mengandung suku n2 atau 2n. Meskipun T(n) = 1.000.000n2, jika U(n) = nx, koefisien
selalu dapat diabaikan, karena n berkembang lebih besar dari 1.000.000.

(T(1.000.000)) = 1.000.000x = U(1.000.000)).

Notasi O Besar mengambil yang tersisa, atau dapat ditulis:

(dibaca O Besar untuk n kuadrat) dan berarti algoritma tersebut memiliki

kompleksitas waktu n2.
Infinitesimal Asymptotic

Notasi O Besar dapat pula digunakan untuk menggambarkan kesalahan dalam sebuah
aproksimasi dalam fungsi matematika. Seperti misalnya : Mengekspresikan bahwa
kesalahannya, memiliki selisih dan lebih kecil dalam nilai absolut dibandingkan
waktu konstan |n|3 untuk x mendekati 0. Dalam analisa asimptotik, kita lebih
mementingkan kecenderungan ukuran (order of magnitude) daripada nilai
aktual/sebenarnya dari sebuah fungsi. Dan lagi, kita tidak perlu mengetahui berapa
lama waktu yang dibutuhkan untuk melakukan suatu operasi pada jenis komputer
tertentu. Yang jelas, kita dengan mudah dapat melihat bahwa n2 adalah fungsi yang
berkembang jauh lebih cepat dibandingkan fungsi linear seperi n. Untuk
menggambarkan kecenderungan ukuran dari suatu operasi, kita menggunakan Notasi O
Besar. Jika kita memiliki algoritma yang melakukan 7n4 + 35n3 19n2 + 3 operasi,
Notasi O Besarnya adalah O(n4). Jika kita memiliki algoritma yang melakukan 2n + 5
operasi, Notasi O Besarnya adalah O(n). Perhitungan tersebut cukup sederhana.

Contoh

Ambil sebuah polinom Dikatakan f(x) memiliki kecenderungan O(g(x)) atau O(x4). Dari
definisi kecenderungan,

|f(x)| < C |g(x)| dimana C konstan.

Pembuktian:

Untuk x > 1 Karena x4 > x3 dan seterusnya.. dengan C = 13.

Notasi

Pernyataan f(x) adalah O(g(x)) sebagaimana didefinisikan sebelumnya, biasa

ditulis f(x) = O(g(x)) Pernyataan ini adalah penyalahgunaan notasi. Persamaan dari
dua buah fungsi tidak dinyatakan. Properti O(g(x)) tidaklah simetrik: Karena alasan
ini, beberapa penulis lebih memilih menggunakan notasi himpunan dan menulis
Menganggap O(g) sebagai himpunan dari fungsi fungsi yang didominasi oleh g. Dalam
penggunaan yang lebih rumit, , O( ) dapat muncul pada tempat yang berbeda di dalam
sebuah persamaan, bahkan beberapa kali untuk masing-masing sisi.

Misalnya, pernyataan berikut benar untuk (n + 1)2 = n2 + O(n) nO(1) = O(en)

Maksud dari pernyataan diatas adalah :

Untuk setiap fungsi yang memenuhi untuk setiap O( ) pada sisi kiri, terdapat
fungsi-fungsi yang memenuhi masing-masing O( ) pada sisi kanan, melakukan
substitusi untuk semua fungsi-fungsi ini ke dalam persamaan menyebabkan kedua sisi
menjadi sama. Misalnya, persamaan ke-3 diatas berarti: Untuk setiap fungsi f(n) =
O(1), terdapat fungsi-fungsi g(n) = O(en) sehingga nf(n) = g(n)

Kecenderungan Fungsi Umum

Di bawah ini adalah klasifikasi dari fungsi-fungsi yang biasa ditemukan dalam
menganalisa sebuah algoritma. Semuanya menggunakan n yang bertambah hingga tak-
hingga. Daftar berikut diurutkan berdasarkan kecepatan pertumbuhan dari fungsi.
Fungsi yang paling lambat berkembang ditulis lebih dahulu. C adalah konstanta yang
dapat berubah.

Notasi Nama Contoh

O(1) Konstan Menentukan apakah suatu bilangan ganjil atau genap

O(log * n) Iterasi logaritmik Algoritma pencarian Hopcraft dan Ullman untuk
himpunan disjoint

O(log n) Logaritmik Pencarian dalam list terurut dengan Binary Search Algorithm

O((log n)c) Polilogaritmik Menentukan bilangan prima dengan AKS primality test

O(n) Linear Pencarian dalam list tidak terurut

O(n log n) Linearitmik Mengurutkan list dengan Heapsort

O(n2) Kuadratik Mengurutkan list dengan Insertion Sort

O(nc), c > 1 Poliomial Pencarian shortest path dengan algoritma Floyd-Warshall

O(cn) Eksponensial Pencarian solusi untuk traveling salesman problem

O(n!) Faktorial Menyelesaikan traveling salesman problem dengan menggunakan brute

force

O(2cn) Dobel Eksponensial Pencarian himpunan lengkap dari AC-unifiers (associative-

commutative unifiers) Tidak biasa, namun pertumbuhan yang jauh lebih cepat masih
mungkin terjadi, seperti versi

satu nilai dari Ackermann function, A(n,n). Sebaliknya, fungsi dengan pertumbuhan
sangat lambat pun dimungkinkan, seperti misalnya invers dari fungsi diatas.
Meskipun tidak memiliki batas, fungsi-fungsi tersebut biasa dianggap konstan dalam
praktik umum.

-------------- Big OH PENJELASAN 2 --------------

-------------- Big OH PENJELASAN 3 --------------

Big O Notation (Notasi Big O)

Big O Notation adalah notasi atau cara penulisan kompleksitas sebuah program.
misalnya program tersebut di ulang dengan "for" sebanyak N kali, maka
kompleksitasnya adalah O(N).
berikut contohnya

i:=0;
while i<N do
begin
i:=i+1;
//statement;
end;

Tapi dalam penulisan Big O ada syarat penulisan, salah satunya adalah "tidak boleh
menyertakan konstanta dalam penulisannya".
Contoh

i:=0;
while i<N do
begin
i:=i*2;
//statement;
end;
sebenarnya kompleksitas code diatas O(2Log N), namun karena big O tuh mempunyai
syarat "konstanta tidak di hitung" maka 2Log N ditulis O(Log N). maka code diatas
di tulis O(Log N).
Contoh lagi

i:= -2;
while i<N do
begin
i:=i+1;
//statement;
end;

kompleksitas potongan program yg di atas itu adalah O(N+2). tapi menurut aturan
penulisan big O, itu hanya di tulis O(n) karena konstanta tidak perlu di tulis.

kenapa konstanta tidak perlu di tulis ?

karena konstanta dapat dihitung dan biasanya tidak mendekati tak hingga. bandingkan
dengan N yg nilai nya mungkin saja bisa meledak hingga limit mendekati tak hingga.
sedangkan konstanta nilai nya sudah terbatas.
contoh lagi

i:=0;
while i<N do
begin
i:=i+1;
j:=0;
while j<N do
begin
j:=j+1;
//statement;
end;
end;

Code diatas memiliki O(N2) karena memiliki double looping.

contoh lagi

i:=0;
while i<N do
begin
i:=i+1;
j:=0;
while j<N do
begin
j:=j+1;
k:=0;
while k<N do
begin
k:=k+1;
//statement;
end;
end;
end;

Sudah tau dong apa jawabannya. yap. O(N3). karena program diatas memiliki triple
looping.
-------------- Big OH PENJELASAN 3 --------------

-------------- Big OH PENJELASAN 4 --------------

O(n2): known as Quadratic complexity

1 item: 1 second
10 items: 100 seconds
100 items: 10000 seconds
Notice that the number of items increases by a factor of 10, but the time increases
by a factor of 102. Basically, n=10 and so O(n2) gives us the scaling factor n2
which is 102.

O(n): known as Linear complexity

1 item: 1 second
10 items: 10 seconds
100 items: 100 seconds
This time the number of items increases by a factor of 10, and so does the time.
n=10 and so O(n)'s scaling factor is 10.

O(1): known as Constant complexity

1 item: 1 second
10 items: 1 second
100 items: 1 second
The number of items is still increasing by a factor of 10, but the scaling factor
of O(1) is always 1.

O(log n): known as Logarithmic complexity

1 item: 1 second
10 items: 2 seconds
100 items: 3 seconds
1000 items: 4 seconds
10000 items: 5 seconds
The number of computations is only increased by a log of the input value. So in
this case, assuming each computation takes 1 second, the log of the input n is the
time required, hence log n.

That's the gist of it. They reduce the maths down so it might not be exactly n2 or
whatever they say it is, but that'll be the dominating factor in the scaling.

-------------- Big OH PENJELASAN 4 --------------