cara menghitung kompleksitas pencarian biner

Saya mendengar seseorang mengatakan bahwa karena pencarian biner membagi dua input yang diperlukan untuk pencarian maka itu adalah log (n) algoritma. Karena saya bukan dari latar belakang matematika saya tidak dapat menghubungkannya. Adakah yang bisa menjelaskannya dengan sedikit lebih detail? apakah itu harus melakukan sesuatu dengan seri logaritmik?

Berikut cara yang lebih matematis untuk melihatnya, meski tidak terlalu rumit. IMO jauh lebih jelas daripada yang informal:

Pertanyaannya adalah, berapa kali Anda bisa membagi N dengan 2 sampai Anda punya 1? Ini pada dasarnya mengatakan, lakukan pencarian biner (setengah elemen) sampai Anda menemukannya. Dalam rumus ini akan menjadi ini:

1 = N / 2 ^x

kalikan dengan 2 ^x :

2 ^x = N

sekarang lakukan log ₂ :

log ₂ (2 ^x ) = log ₂ N
x * log ₂ (2) = log ₂ N
x * 1 = log ₂ N

ini berarti Anda dapat membagi log N kali hingga semuanya terbagi. Yang berarti Anda harus membagi log N ("lakukan langkah pencarian biner") hingga Anda menemukan elemen Anda.

Untuk Pencarian Biner, T (N) = T (N / 2) + O (1) // relasi perulangan

Terapkan Teorema Master untuk komputasi Run time kompleksitas hubungan perulangan: T (N) = aT (N / b) + f (N)

Di sini, a = 1, b = 2 => log (a basis b) = 1

juga, di sini f (N) = n ^ c log ^ k (n) // k = 0 & c = log (a basis b)

Jadi, T (N) = O (N ^ c log ^ (k + 1) N) = O (log (N))

Sumber: http://en.wikipedia.org/wiki/Master_theorem

T (n) = T (n / 2) +1

T (n / 2) = T (n / 4) + 1 + 1

Masukkan nilai The (n / 2) di atas sehingga T (n) = T (n / 4) + 1 + 1. . . . T (n / 2 ^ k) + 1 + 1 + 1 ..... + 1

= T (2 ^ k / 2 ^ k) + 1 + 1 .... + 1 hingga k

= T (1) + k

Seperti yang kita ambil 2 ^ k = n

K = log n

Jadi kompleksitas waktu adalah O (log n)

Itu tidak setengah waktu pencarian, itu tidak akan membuatnya masuk (n). Itu menguranginya secara logaritmik. Pikirkan ini sejenak. Jika Anda memiliki 128 entri dalam tabel dan harus mencari nilai Anda secara linear, mungkin butuh sekitar 64 entri untuk menemukan nilai Anda. Itu n / 2 atau waktu linier. Dengan pencarian biner, Anda menghilangkan 1/2 entri yang mungkin setiap iterasi, sehingga paling banyak hanya perlu 7 perbandingan untuk menemukan nilai Anda (log basis 2 dari 128 adalah 7 atau 2 hingga 7 daya adalah 128.) Ini adalah kekuatan pencarian biner.

Kompleksitas waktu dari algoritma pencarian biner termasuk dalam kelas O (log n). Ini disebut notasi O besar . Cara Anda menginterpretasikan ini adalah bahwa pertumbuhan asimptotik dari waktu yang diperlukan untuk mengeksekusi diberi set input ukuran n tidak akan melebihi log n.

Ini hanya istilah matematika formal untuk dapat membuktikan pernyataan, dll. Ini memiliki penjelasan yang sangat mudah. Ketika n tumbuh sangat besar, fungsi log n akan menumbuhkan waktu yang diperlukan untuk menjalankan fungsi. Ukuran "set input", n, hanya panjang dari daftar.

Sederhananya, alasan pencarian biner adalah dalam O (log n) adalah karena membagi dua set input di setiap iterasi. Lebih mudah untuk memikirkannya dalam situasi sebaliknya. Pada x iterasi, berapa lama daftar yang dapat diperiksa algoritma pencarian biner? Jawabannya adalah 2 ^ x. Dari ini kita dapat melihat bahwa kebalikannya adalah bahwa rata-rata algoritma pencarian biner membutuhkan iterasi log2 n untuk daftar panjang n.

Jika mengapa itu O (log n) dan bukan O (log2 n), itu karena cukup dimasukkan lagi - Menggunakan konstanta notasi O besar tidak masuk hitungan.

Inilah entri wikipedia

Jika Anda melihat pendekatan iteratif sederhana. Anda hanya menghilangkan setengah dari elemen yang akan dicari sampai Anda menemukan elemen yang Anda butuhkan.

Inilah penjelasan tentang bagaimana kita menghasilkan formula.

Katakan pada awalnya Anda memiliki N jumlah elemen dan kemudian apa yang Anda lakukan adalah ⌊N / 2⌋ sebagai upaya pertama. Di mana N adalah jumlah dari batas bawah dan batas atas. Nilai waktu pertama N akan sama dengan (L + H), di mana L adalah indeks pertama (0) dan H adalah indeks terakhir dari daftar yang Anda cari. Jika Anda beruntung, elemen yang Anda coba temukan ada di tengah [mis. Anda mencari 18 dalam daftar {16, 17, 18, 19, 20} kemudian Anda menghitung ⌊ (0 + 4) / 2⌋ = 2 di mana 0 terikat lebih rendah (L - indeks elemen pertama array) dan 4 adalah batas yang lebih tinggi (H - indeks elemen terakhir dari array). Dalam kasus di atas L = 0 dan H = 4. Sekarang 2 adalah indeks dari elemen 18 yang Anda cari ditemukan. Bingo! Anda menemukannya.

Jika case adalah array yang berbeda {15,16,17,18,19} tetapi Anda masih mencari 18 maka Anda tidak akan beruntung dan Anda akan melakukan yang pertama N / 2 (yaitu ⌊ (0 + 4) / 2⌋ = 2 dan kemudian menyadari elemen 17 pada indeks 2 bukan angka yang Anda cari. Sekarang Anda tahu bahwa Anda tidak harus mencari setidaknya setengah dari array dalam upaya Anda berikutnya untuk mencari secara iteratif. upaya pencarian dibelah dua. Jadi pada dasarnya, Anda tidak mencari setengah dari daftar elemen yang Anda cari sebelumnya, setiap kali Anda mencoba menemukan elemen yang tidak dapat Anda temukan dalam upaya Anda sebelumnya.

Jadi kasus terburuk adalah

[N] / 2 + [(N / 2)] / 2 + [((N / 2) / 2)] / 2 .....
yaitu:
N / 2 ¹ + N / 2 ² + N / 2 ³ + ..... + N / 2 ^x … ..

sampai ... Anda selesai mencari, di mana dalam elemen yang Anda coba temukan ada di ujung daftar.

Itu menunjukkan kasus terburuk adalah ketika Anda mencapai N / 2 ^{x di} mana x sedemikian rupa sehingga 2 ^x = N

Dalam kasus lain N / 2 ^{x di} mana x sedemikian rupa sehingga 2 ^x <N Nilai minimum x dapat 1, yang merupakan kasus terbaik.

Sekarang karena kasus terburuk secara matematis adalah ketika nilai
2 ^x = N
=> log ₂ (2 ^x ) = log ₂ (N)
=> x * log ₂ (2) = log ₂ (N)
=> x * 1 = log ₂ (N)
=> Lebih resmi ⌊log ₂ (N) + 1⌋

Log2 (n) adalah jumlah maksimum pencarian yang diperlukan untuk menemukan sesuatu dalam pencarian biner. Kasus rata-rata melibatkan pencarian log2 (n) -1. Inilah info lebih lanjut:

http://en.wikipedia.org/wiki/Binary_search#Performance

Katakanlah iterasi dalam Pencarian Biner berakhir setelah iterasi k. Pada setiap iterasi, array dibagi setengah. Jadi misalkan panjang array pada setiap iterasi adalah n Pada Iteration 1,

Length of array = n

Pada Perulangan 2,

Length of array = n⁄2

Pada Perulangan 3,

Length of array = (n⁄2)⁄2 = n⁄22

Oleh karena itu, setelah Iterasi k,

Length of array = n⁄2k

Juga, kita tahu bahwa setelah pembagian Setelah k, panjang array menjadi 1 Oleh karena itu

Length of array = n⁄2k = 1
=> n = 2k

Menerapkan fungsi log di kedua sisi:

=> log2 (n) = log2 (2k)
=> log2 (n) = k log2 (2)
As (loga (a) = 1)

Karena itu,

As (loga (a) = 1)
k = log2 (n)

Karenanya kompleksitas waktu dari Pencarian Biner adalah

log2 (n)

Pencarian biner berfungsi dengan membagi masalah menjadi dua berulang kali, sesuatu seperti ini (rincian dihilangkan):

Contoh mencari 3 dalam [4,1,3,8,5]

1. Pesan daftar barang Anda [1,3,4,5,8]
2. Lihat item tengah (4),
   • Jika itu yang Anda cari, berhentilah
   • Jika lebih besar, lihat bagian pertama
   • Jika kurang, lihat bagian kedua
3. Ulangi langkah 2 dengan daftar baru [1, 3], temukan 3 dan berhenti

Ini adalah pencarian dua kali sehari ketika Anda membagi masalah menjadi 2.

Pencarian hanya membutuhkan langkah-langkah log2 (n) untuk menemukan nilai yang benar.

Saya akan merekomendasikan Pengantar Algoritma jika Anda ingin belajar tentang kompleksitas algoritmik.

Karena kita memotong daftar menjadi setengah setiap kali karena itu kita hanya perlu tahu berapa banyak langkah yang kita dapatkan 1 saat kita terus membagi daftar dengan dua. Dalam perhitungan yang diberikan x menunjukkan jumlah waktu kita membagi daftar sampai kita mendapatkan satu elemen (Dalam Kasus Terburuk).

1 = N / 2x

2x = N

Mengambil log2

log2 (2x) = log2 (N)

x * log2 (2) = log2 (N)

x = log2 (N)

T (N) = T (N / 2) + 1

T (N) = T (N / 2) + 1 = (T (N / 4) + 1) + 1

...

T (N) = T (N / N) + (1 + 1 + 1 + ... + 1) = 1 + logN (basis 2 log) = 1 + logN

Jadi kompleksitas waktu pencarian biner adalah O (logN)

ok see this
for(i=0;i<n;n=n/2)
{
i++;
}
1. Suppose at i=k the loop terminate. i.e. the loop execute k times.

2. at each iteration n is divided by half.

2.a n=n/2                   .... AT I=1
2.b n=(n/2)/2=n/(2^2)
2.c n=((n/2)/2)/2=n/(2^3)....... aT I=3
2.d n=(((n/2)/2)/2)/2=n/(2^4)

So at i=k , n=1 which is obtain by dividing n  2^k times
n=2^k
1=n/2^k 
k=log(N)  //base 2

Biarkan saya membuatnya mudah bagi Anda semua dengan sebuah contoh.

Untuk tujuan kesederhanaan, mari kita asumsikan ada 32 elemen dalam array dalam urutan diurutkan dari mana kita mencari elemen menggunakan pencarian biner.

1 2 3 4 5 6 ... 32

Asumsikan kita sedang mencari 32. setelah iterasi pertama, kita akan dibiarkan

17 18 19 20 .... 32

setelah iterasi kedua, kita akan dibiarkan dengan

25 26 27 28 .... 32

setelah iterasi ketiga, kita akan dibiarkan dengan

29 30 31 32

setelah iterasi keempat, kita akan dibiarkan dengan

31 32

Pada iterasi kelima, kita akan menemukan nilai 32.

Jadi, jika kita mengonversi ini menjadi persamaan matematika, kita akan dapatkan

(32 X (1/2 ⁵ )) = 1

=> n X (2 ^-k ) = 1

=> (2 ^k ) = n

=> k log ₂ 2 = log ₂ n

=> k = log ₂ n

Karena itu buktinya.

Berikut ini solusinya menggunakan teorema master, dengan LaTeX yang dapat dibaca.

Untuk setiap perulangan dalam relasi perulangan untuk pencarian biner, kami mengonversi masalahnya menjadi satu subproblem, dengan runtime T (N / 2). Karena itu:

Mengganti ke dalam teorema master, kita mendapatkan:

Sekarang, karena 0 dan f (n) adalah 1, kita dapat menggunakan kasus kedua dari teorema master karena:

Ini berarti: