algoritma pencarian biner
DESCRIPTION
algoritma pencarian binerTRANSCRIPT
Algoritma pencarian biner (BINARY SEARCH)
Rate This
salah satu tugas kuliah presentasi (struktur data) pada minggu ini telah saya rilis resmi di
ariefokebanget.wordpress.com ini, bagi rekan lain yang mengambil mata kuliah serupa di Study
Teknik Informatika semoga postingan ini berguna untuk referensi
Umumnya, untuk mencari sebuah nilai dalam array disortir, kita harus melihat melalui elemen-
elemen dari array satu per satu, sampai mencari nilai ditemukan. Dalam kasus pencarian nilai
absen dari array, kita melewati semua elemen. Rata-rata, kompleksitas algoritma tersebut
adalah proporsional dengan panjang array.
==========================
| 15 | 8 | 1 | 24 | 17 |
|------------------------|
| 16 | 14 | 7 | 5 | 23 |
|------------------------|
| 22 | 20 | 13 | 6 | 4 |
|------------------------|
| 3 | 21 | 19 | 12 | 10 |
|------------------------|
| 9 | 2 | 25 | 18 | 11 |
==========================
Situasi perubahan signifikan, ketika array diurutkan. Jika kita tahu itu, kemampuan akses acak
dapat dimanfaatkan sangat efisien untuk menemukan pencarian nilai cepat. Biaya algoritma
pencarian mengurangi untuk logaritma biner dari panjang array. Untuk referensi, log2 (1 000
000) ≈ 20. Ini berarti, bahwa dalam kasus terburuk, algoritma membuat 20 langkah untuk
menemukan nilai dalam array diurutkan dari satu juta elemen atau mengatakan, bahwa ia tidak
hadir itu array.
Algoritma
Algoritma cukup sederhana. Hal ini dapat dilakukan secara rekursif salah satu atau iteratif:
1. mendapatkan elemen tengah;
2. jika elemen tengah sama dengan nilai yang dicari, algoritma akan berhenti;
3. sebaliknya, dua kasus yang mungkin:
* Mencari nilai kurang, dari elemen tengah. Dalam hal ini, pergi ke langkah 1 untuk bagian array,
sebelum elemen tengah.
* Mencari nilai lebih besar, daripada elemen tengah. Dalam hal ini, pergi ke langkah 1 untuk
bagian array, setelah elemen tengah.
Sekarang kita harus mendefinisikan, kapan iterasi harus berhenti. Kasus pertama adalah ketika
dicari unsur ditemukan. Kedua satu adalah ketika subarray tidak memiliki elemen. Dalam hal ini,
kita dapat menyimpulkan, bahwa mencari nilai tidak hadir dalam array.
Contoh
Contoh 1. Cari 6 di {-1, 5, 6, 18, 19, 25, 46, 78, 102, 114}.
Langkah 1 (elemen tengah adalah 19> 6): -1 5 6 18 19 25 46 78 102 114
Langkah 2 (elemen tengah adalah 5 <6): -1 5 6 18 19 25 46 78 102 114
Langkah 3 (elemen tengah adalah 6 == 6): -1 5 6 18 19 25 46 78 102 114
Contoh 2. Cari 103 di {-1, 5, 6, 18, 19, 25, 46, 78, 102, 114}.
Langkah 1 (elemen tengah adalah 19 <103): -1 5 6 18 19 25 46 78 102 114
Langkah 2 (elemen tengah adalah 78 <103): -1 5 6 18 19 25 46 78 102 114
Langkah 3 (elemen tengah adalah 102 <103): -1 5 6 18 19 25 46 78 102 114
Langkah 4 (elemen tengah adalah 114> 103): -1 5 6 18 19 25 46 78 102 114
Langkah 5 (dicari nilai tidak ada): -1 5 6 18 19 25 46 78 102 114
Analisis Kompleksitas
keuntungan besar dari algoritma ini adalah bahwa kompleksitas itu tergantung pada ukuran
array logaritmis dalam kasus terburuk. Dalam prakteknya ini berarti, algoritma yang akan
melakukan paling banyak log2 (n) iterasi, yang merupakan jumlah yang sangat kecil, bahkan
untuk array besar. Hal ini dapat terbukti sangat mudah. Memang, pada setiap langkah ukuran
dicari bagian berkurang setengahnya. Algoritma berhenti, jika tidak ada unsur untuk mencari
masuk Oleh karena itu, pemecahan ketimpangan berikut dalam bilangan bulat:
n / 2iterations> 0
mengakibatkan
Iterasi <= log2 (n).
Ini berarti, bahwa kompleksitas waktu algoritma pencarian biner adalah O (log2 (n)).
Kode snippet.
Anda dapat melihat solusi rekursif untuk Java dan berulang untuk C + + di bawah ini.
Java
/ **
* Mencari nilai dalam array diurutkan
*
* @ Param array
* Array untuk mencari di
* @ Param nilai
* Pencarian nilai
* @ Param kiri
* Indeks dari batas kiri
* @ Param kanan
* Indeks dari batas kanan
* @ Return posisi pencarian nilai, jika menyajikan dalam array atau -1, jika
* Itu tidak ada
* /
binarySearch int (int [] array, nilai int, int kiri, kanan int) {
if (kanan> kiri)
return -1;
int tengah = (kiri + kanan) / 2;
if (array [tengah] == nilai)
kembali menengah;
else if (array [tengah] nilai>)
kembali binarySearch (array, nilai, kiri, tengah – 1);
lain
kembali binarySearch (array, nilai, tengah + 1, kanan);
}
C + +
/ *
* Mencari nilai dalam array diurutkan
* Arr adalah array untuk mencari di
* Nilai dicari nilai
* Kiri adalah indeks dari batas kiri
* Benar adalah suatu indeks batas kanan
* Kembali posisi pencarian nilai, jika menyajikan dalam array
* Atau -1, jika tidak hadir
* /
int binarySearch (int arr [], nilai int, int kiri, kanan int) {
while (<kiri = kanan) {
int tengah = (kiri + kanan) / 2;
if (arr [tengah] == nilai)
kembali menengah;
else if (arr [tengah]> nilai)
kanan = tengah – 1;
lain
kiri = tengah + 1;
}
return -1;
}
Visualizers
1. Pencarian biner di Jawa Applet Pusat
Dua tanggapan untuk “Binary Search Tutorial”
1. Tamu pada 20 Oktober 2009 mengatakan:
Nilai terakhir tidak pernah readed. Sebagai contoh …
int [] a = {0, 3, 1, 7, 2, 8, 12, 53, 64, 95, 6, 71, 84, 9};
dan saya ingin mencari nomor 9
ia mengembalikan bahwa 9 tidak di dalam array
Algoritma mensyaratkan bahwa sumber array diurutkan dalam rangka untuk pekerjaan yang
tepat.
2. Andres on Nov 5, 2008 mengatakan:
Hi, salam dari Argentina. Saya tidak tahu apakah situs ini terlalu lama atau sangat baru.
Anyway, saya percaya ada kesalahan dengan pencarian biner. Saya menyadari bahwa ketika
“jika (arr [tengah]> nilai)” adalah benar, itu berarti bahwa Anda membuang paruh pertama
array Anda, mengingat 0,1,2 ,…, n. Kemudian, dalam hal itu, kalimat berikutnya harus kiri =
tengah + 1 bukannya kanan = tengah-1, yang membuat Anda mempertimbangkan hanya paruh
pertama dari array. Best keinginan, Andres dari Buenos Aires, Argentina.
Ada kesalahan. Jika kondisi “nilai <arr [tengah]” adalah benar, itu berarti, bahwa nilai dapat
hadir hanya di bagian pertama dari array. Dalam hal ini bagian kedua dari array dibuang dan
pencarian berlanjut di bagian pertama.
Pemrograman algoritma pencarian biner
terbaru saya proyek rekayasa perangkat lunak terdiri dari menulis sebuah program yang akan
menulis algoritma pencarian biner. Dalam proyek saya sebelumnya, saya telah menyebutkan
bahwa Aku menghindari menggunakan array, tapi dalam proyek ini saya harus menggunakan
array. Array adalah suatu pengaturan benda, tetapi dalam kasus ini akan menjadi sebuah
susunan bilangan bulat. Fungsi pencarian biner harus melihat ke dalam array dan menemukan
indeks dimana nilai sedang diadakan.
Untuk proyek ini saya memutuskan untuk mengambil langkah ekstra. Saya menganggap bahwa
ukuran kolam data yang diberikan dan data diurutkan. Namun saya mengambil pendekatan
untuk mengetahui bagaimana untuk secara dinamis mengalokasikan array dalam pemrograman
tentu saja saya C selama run-time. Ini berarti, bahwa program ini akan meminta pengguna
untuk ukuran array, daripada memiliki ukuran tetap. Bagian ini tidak terlalu sulit. Saya perlu
mengalokasikan ruang dalam memori komputer untuk dapat membuat sebuah array yang akan
masuk dalam memori yang dialokasikan.
Jadi sekarang bahwa aku telah mengatur array saya pada saat run-time, aku sekarang
memberikan pengguna pilihan untuk memasukkan data kolam renang. Namun saya harus
memastikan bahwa data diurutkan, sebagai pengguna input data mungkin tidak dalam urutan
tertentu. Ini rumit, karena saya tidak bekerja dengan array sebelumnya, saya mencari online
tentang cara mengurutkan array, dan saya menemukan teknik penyortiran disebut bubble sort.
menyortir Bubble terdiri dari melihat melalui array dan membandingkan nilai yang berdekatan
dan swapping mereka jika mereka berada di urutan yang salah. Jenis pengurutan agak lambat,
tetapi dalam kasus saya, saya tidak mengharapkan untuk mengurutkan melemparkan kolam
besar data. Great, jadi sekarang saya telah membentuk array dinamis saya dan saya sudah
mengurutkannya array, sekarang saya bisa fokus pada penulisan algoritma pencarian biner.
Ide dibalik algoritma pencarian biner atau algoritma pencarian setengah interval untuk
membandingkan dua nilai (indeks pertama dan indeks terakhir) ke tengah indeks array, jika
nilai-nilai yang sama, ada nilai telah ditemukan, jika tidak, akan mengambil seperangkat nilai
dan membandingkan indeks tengah lagi sampai nilai-nilai yang sama.
Perbandingan ini dilakukan dengan perbandingan ukuran, adalah indeks tengah lebih besar atau
lebih kecil dari permintaan pencarian. Untuk bagian ini saya mencoba beberapa metode dan
saya tidak mendapatkan apa yang saya tenang yang diharapkan, jadi apa yang saya
memutuskan untuk melakukan, adalah untuk secara visual melihat bagaimana algoritma itu
bekerja dan untuk itu aku contoh di atas kertas dan pena. Setelah saya melihat apa yang
sebenarnya perlu terjadi, saya kemudian bisa menulis algoritma sehingga meniru proses
tersebut.
Saya menemukan bahwa menulis algoritma ke bawah di kertas membantu banyak karena saya
mampu memecahkan algoritma setelah 1 coba tunggal setelah menulis ke bawah, dibandingkan
dengan 2 kegagalan sebelumnya saya hanya memikirkan algoritma. Ini adalah bagaimana saya
pergi tentang rekayasa perangkat lunak saya menyelesaikan proyek untuk matakuliah
Pemrograman C. Saya senang bekerja pada proyek ini terutama karena saya melakukan
sebagian besar pekerjaan tanpa mendapatkan bantuan tambahan
http://ariefokebanget.wordpress.com/2011/05/08/algoritma-pencarian-biner-binary-search/