Implementasi Penerapan Algoritma Boyer-Moore

Pencarian pola merupakan masalah penting dalam ilmu komputer. Saat kita melakukan
pencarian string di file notepad/word, browser, atau database, algoritma pencarian pola
digunakan untuk menampilkan hasil pencarian. Pernyataan masalah yang khas adalah-
Diberikan teks txt[0..n-1] dan pola pat[0..m-1] di mana n adalah panjang teks dan m adalah
panjang pola, tuliskan fungsi search(char pat[] , char txt[]) yang mencetak semua
kemunculan pat[] di txt[]. Anda mungkin berasumsi bahwa n > m.
Contoh:

Pada postingan kali ini kita akan membahas algoritma pencarian pola Boyer Moore.
Seperti algoritma KMP dan Finite Automata, algoritma Boyer Moore juga melakukan
praproses terhadap pola tersebut. Boyer Moore merupakan kombinasi dari dua pendekatan
berikut:
1. Heuristik Karakter Buruk
2. Heuristik Sufiks yang Baik
Kedua heuristik di atas juga dapat digunakan secara mandiri untuk mencari suatu pola dalam
sebuah teks. Pertama-tama mari kita pahami bagaimana dua pendekatan independen
bekerja sama dalam algoritma Boyer Moore. Jika kita melihat pada algoritma Naive,
algoritma ini menggeser pola ke atas teks satu per satu. Algoritma KMP melakukan
preprocessing terhadap pola tersebut sehingga pola tersebut dapat digeser lebih dari satu.
Algoritma Boyer Moore melakukan prapemrosesan untuk alasan yang sama. Ini memproses
pola dan membuat array berbeda untuk masing-masing dari dua heuristik. Pada setiap
langkah, ia menggeser pola sebanyak maksimal slide yang disarankan oleh masing-masing
dua heuristik. Jadi ia menggunakan offset terbesar yang disarankan oleh dua heuristik pada
setiap langkah.
Berbeda dengan algoritma pencarian pola sebelumnya, algoritma Boyer Moore
memulai pencocokan dari karakter terakhir dari pola tersebut. Pada postingan kali ini kita
akan membahas tentang heuristik karakter buruk dan heuristik Sufiks Baik pada postingan
selanjutnya.

1.Heuristik Karakter Buruk

Ide heuristik karakter buruk itu sederhana. Karakter teks yang tidak sesuai dengan
karakter pola saat ini disebut Karakter Buruk. Jika tidak cocok, kami menggeser polanya
hingga
1. Ketidakcocokan menjadi sebuah kecocokan.

2. Pola P bergerak melewati karakter yang tidak cocok.

Kasus 1 Ketidakcocokan menjadi kecocokan

Kita akan mencari posisi kemunculan terakhir dari karakter yang tidak cocok pada
pola tersebut, dan jika karakter yang tidak cocok tersebut ada pada pola tersebut, maka kita
akan menggeser pola tersebut hingga menjadi sejajar dengan karakter yang tidak cocok
tersebut pada teks T.

Penjelasan: Pada contoh di atas, kita mendapatkan ketidakcocokan pada posisi 3. Di sini
karakter ketidakcocokan kita adalah “A”. Sekarang kita akan mencari kemunculan terakhir
dari pola “A”. Kami mendapat “A” di posisi 1 dalam pola (ditampilkan dalam warna Biru) dan
ini adalah kemunculan terakhirnya. Sekarang kita akan menggeser pola sebanyak 2 kali
sehingga pola “A” sejajar dengan teks “A”
Kasus 2 – Pola bergerak melewati karakter yang tidak cocok
Kami akan mencari posisi kemunculan terakhir karakter yang tidak cocok dalam pola dan jika
karakter tidak ada, kami akan menggeser pola melewati karakter yang tidak cocok tersebut.

Penjelasan:
Di sini kita memiliki ketidakcocokan di posisi 7. Karakter "C" yang tidak cocok tidak ada
dalam pola sebelum posisi 7 jadi kita akan menggeser pola melewati posisi 7 dan akhirnya
dalam contoh di atas kita mendapatkan pola yang sangat cocok (ditampilkan dalam Hijau).
Hal ini kita lakukan karena “C” tidak ada pada polanya sehingga pada setiap shift sebelum
posisi 7 akan terjadi ketidakcocokan dan pencarian kita tidak membuahkan hasil.
Dalam implementasi berikut, kami melakukan praproses pola dan menyimpan kemunculan
terakhir dari setiap karakter yang mungkin dalam array dengan ukuran yang sama dengan
ukuran alfabet. Jika karakter tidak ada sama sekali, maka dapat mengakibatkan pergeseran
sebesar m (panjang pola). Oleh karena itu, heuristik karakter buruk membutuhkan waktu
O(n/m) dalam kasus terbaik.

/* C++ Program for Bad Character Heuristic of Boyer

Moore String Matching Algorithm */
#include <bits/stdc++.h>
using namespace std;
# define NO_OF_CHARS 256

// The preprocessing function for Boyer Moore's

// bad character heuristic
void badCharHeuristic( string str, int size,
int badchar[NO_OF_CHARS])
{
int i;

// Initialize all occurrences as -1

for (i = 0; i < NO_OF_CHARS; i++)
badchar[i] = -1;

// Fill the actual value of last occurrence

// of a character
for (i = 0; i < size; i++)
badchar[(int) str[i]] = i;
}

/* A pattern searching function that uses Bad

Character Heuristic of Boyer Moore Algorithm */
void search( string txt, string pat)
{
int m = pat.size();
int n = txt.size();

int badchar[NO_OF_CHARS];

/* Fill the bad character array by calling

the preprocessing function badCharHeuristic()
for given pattern */
badCharHeuristic(pat, m, badchar);

int s = 0; // s is shift of the pattern with

// respect to text
while(s <= (n - m))
{
int j = m - 1;

/* Keep reducing index j of pattern while

characters of pattern and text are
matching at this shift s */
while(j >= 0 && pat[j] == txt[s + j])
j--;

/* If the pattern is present at current

shift, then index j will become -1 after
the above loop */
if (j < 0)
{
cout << "pattern occurs at shift = " << s << endl;

/* Shift the pattern so that the next

character in text aligns with the last
occurrence of it in pattern.
The condition s+m < n is necessary for
the case when pattern occurs at the end
of text */
s += (s + m < n)? m-badchar[txt[s + m]] : 1;

else
/* Shift the pattern so that the bad character
 in text aligns with the last occurrence of
it in pattern. The max function is used to
make sure that we get a positive shift.
We may get a negative shift if the last
occurrence of bad character in pattern
is on the right side of the current
character. */
s += max(1, j - badchar[txt[s + j]]);
}
}

/* Driver code */
int main()
{
string txt= "ABAAABCD";
string pat = "ABC";
search(txt, pat);
return 0;
}

// This code is contributed by rathbhupendra

Output
pattern occurs at shift = 4
Kompleksitas Waktu : O(n x m)
Ruang Tambahan: O(1)
Heuristik Karakter Buruk mungkin memerlukan waktu O(mn) dalam kasus terburuk.
Kasus terburuk terjadi ketika semua karakter teks dan polanya sama. Misalnya, txt[] =
“AAAAAAAAAAAAAAAAAA” dan pat[] = “AAAAA”. Heuristik Karakter Buruk mungkin
memerlukan O(n/m) dalam kasus terbaik. Kasus terbaik terjadi ketika semua karakter teks
dan pola berbeda.
https://www.geeksforgeeks.org/boyer-moore-algorithm-for-pattern-searching/
2. Heuristik Sufiks yang Baik
Heuristik untuk pencarian pola. Sama seperti heuristik karakter buruk, tabel
prapemrosesan dibuat untuk heuristik sufiks yang baik.
Heuristik Sufiks yang Baik
Membiarkan
T
menjadi substring teks
T
yang cocok dengan substring pola
P
Sekarang kita menggeser polanya sampai : 1) Kemunculan t lagi di P yang cocok
dengan t di T. 2) Awalan P, yang cocok dengan akhiran t 3) P bergerak melewati t

Kasus 1: Kemunculan t lainnya di P cocok dengan t di T

Pola P mungkin mengandung lebih sedikit kemunculan
T
Dalam hal ini, kami akan mencoba menggeser pola untuk menyelaraskan kejadian
tersebut dengan t di teks T. Misalnya:

Penjelasan:
Pada contoh di atas, kita mendapatkan substring t dari teks T yang cocok dengan pola
P (berwarna hijau) sebelum ketidakcocokan pada indeks 2. Sekarang kita akan mencari
kemunculan t (“AB”) di P. Kita telah menemukan kemunculan yang dimulai pada posisi 1
(berlatar belakang kuning) jadi kita geser polanya ke kanan sebanyak 2 kali untuk
menyelaraskan t di P dengan t di T. Ini adalah aturan lemah dari Boyer Moore asli dan tidak
terlalu efektif, kita akan membahas aturan Sufiks Baik yang Kuat.

Kasus 2: Awalan P, yang cocok dengan akhiran t di T

Tidak selalu mungkin kita akan menemukan kemunculan t di P. Terkadang tidak ada
kemunculan sama sekali, dalam kasus seperti ini terkadang kita dapat mencari
beberapanakhiran t cocok dengan beberapa awalan P dan coba sejajarkan dengan
menggeser P. Misalnya:

Penjelasan:
Dalam contoh di atas, kita mendapatkan t (“BAB”) yang cocok dengan P (berwarna
hijau) pada indeks 2-4 sebelum mismatch. Tetapi karena tidak ada kemunculan t di P, kita
akan mencari beberapa awalan P yang cocok dengan beberapa akhiran t. Kami telah
menemukan awalan “AB” (dengan latar belakang kuning) dimulai dari indeks 0 yang tidak
cocok dengan keseluruhan t tetapi akhiran t “AB” yang dimulai dari indeks 3. Jadi sekarang
kita akan menggeser pola sebanyak 3 kali untuk menyelaraskan awalan dengan akhiran .

Kasus 3: P bergerak melewati t

Jika kedua kasus di atas tidak terpenuhi, kita akan menggeser pola melewati t. Misalnya:
Penjelasan:
Jika contoh di atas, tidak ada kemunculan t (“AB”) di P dan juga tidak ada awalan di P
yang cocok dengan akhiran t. Jadi, dalam hal ini, kita tidak akan pernah menemukan
kecocokan sempurna sebelum indeks 4, jadi kita akan menggeser P melewati angka t yaitu.
untuk mengindeks 5. Heuristik akhiran Baik yang Kuat Misalkan substring
q = P[i sampai n] cocok dengan
T di T dan c = P[i-1]
adalah karakter yang tidak cocok. Sekarang berbeda dengan kasus 1 kita akan mencari t di P
yang tidak didahului oleh karakter C.
Kejadian terdekat tersebut kemudian disejajarkan dengan t di T dengan menggeser pola P.
Misalnya:

Penjelasan:
Dalam contoh di atas,
q = P[7 hingga 8]
dicocokkan dengan t di T. Karakter yang tidak cocok C adalah “C” pada posisi P[6]. Sekarang
jika kita mulai mencari t di P kita akan mendapatkan kemunculan t pertama yang dimulai
pada posisi 4. Namun kemunculan ini didahului oleh “C” yang sama dengan c, jadi kita lewati
ini dan lanjutkan pencarian. Pada posisi 1 kita mendapat kemunculan t lainnya (dengan latar
belakang kuning). Kejadian ini diawali dengan “A” (berwarna biru) yang tidak setara dengan
c. Jadi kita akan menggeser pola P sebanyak 6 kali untuk menyelaraskan kejadian ini dengan
t di T. Kita melakukan ini karena kita sudah mengetahui karakter tersebut c = “C”
menyebabkan ketidaksesuaian. Jadi setiap kemunculan t yang diawali dengan c akan kembali
menyebabkan ketidakcocokan jika disejajarkan dengan t, oleh karena itu lebih baik dilewati
saja. Pemrosesan awal untuk heuristik sufiks yang baik. Sebagai bagian dari prapemrosesan,
sebuah array menggeser dibuat. Setiap entri pergeseran[i] mengandung pola jarak akan
bergeser jika terjadi ketidaksesuaian pada posisi i-1. Yaitu sufiks pola yang dimulai dari posisi
Saya cocok dan ketidakcocokan terjadi pada posisinya i-1. Pemrosesan awal dilakukan secara
terpisah untuk sufiks kuat yang baik dan kasus 2 yang dibahas di atas.
1) Pemrosesan awal untuk Sufiks Baik yang Kuat
Sebelum membahas preprocessing, mari kita bahas dulu ide tentang border. A berbatasan
adalah substring yang merupakan sufiks dan awalan yang tepat. Misalnya saja pada string
“ccacc”, "C" adalah perbatasan, “cc” adalah batas karena muncul di kedua ujung string tetapi
“ca” bukan merupakan perbatasan. Sebagai bagian dari pemrosesan awal array bpos (posisi
perbatasan) dihitung. Setiap entri bpos[i] berisi indeks awal batas untuk sufiks yang dimulai
dari indeks i dalam pola tertentu P. Sufiks? dimulai dari posisi m tidak memiliki batas, jadi
bpos[m] diatur ke m+1 Di mana M adalah panjang polanya. Pergeseran posisi tersebut
diperoleh dengan batas yang tidak dapat diperpanjang ke kiri. Berikut adalah kode untuk
prapemrosesan:

Penjelasan:
Pertimbangkan polanya
P = “ABBABAB”, m = 7

 Batas terlebar sufiks “AB” yang bermula pada posisi i = 5 adalah ?(tidak ada) yang
bermula pada posisi 7 sehingga bpos[5] = 7.
 Pada posisi i = 2 sufiksnya adalah “BABAB”. Batas terlebar sufiks ini adalah “BAB”
dimulai dari posisi 4, jadi j = bpos[2] = 4.
 Kami bisa mengerti
 bpos[i] = j
 menggunakan contoh berikut:

 Jika karakter
 #
 Yang ada pada posisinya
 i-1
 setara dengan karakter
 ?
 di posisi
 j-1
 , kita tahu perbatasan itu akan terjadi
 ? + batas akhiran pada posisi i
 yang dimulai dari posisi
 J
 yang setara dengan mengatakan itu
 batas akhiran pada i-1 dimulai pada j-1
 atau
 bpos[ i-1 ] = j-1
 atau dalam kode:

 Tapi jika karakter

 #
 di posisi
 i-1
 tidak sesuai dengan karakternya
 ?
 di posisi
 j-1
 lalu kita lanjutkan pencarian kita ke arah kanan. Sekarang kita tahu bahwa –
 Lebar border akan lebih kecil dibandingkan dengan border yang dimulai pada posisi j
yaitu. lebih kecil dari x…?
 Perbatasan harus dimulai dengan # dan diakhiri dengan ? atau bisa saja kosong (tidak
ada batasnya).
 Dengan dua fakta di atas kami akan melanjutkan pencarian kami di sub string
 X…?
 dari posisi
 j ke m
 . Perbatasan selanjutnya seharusnya berada di
 j = bpos[j]
 . Setelah memperbarui
 J
 , kita kembali membandingkan karakter pada posisinya
 j-1 (?)
 dengan # dan jika keduanya sama maka kita mendapatkan perbatasannya jika tidak,
kita lanjutkan pencarian ke kanan
 sampai j>m
 . Proses ini ditunjukkan oleh kode:

 Dalam kode di atas lihat kondisi ini :

 Ini adalah kondisi yang kita diskusikan dalam kasus 2. Ketika karakter sebelum
kemunculan t di pola P berbeda dengan karakter yang tidak cocok di P, kita berhenti
melewatkan kemunculannya dan menggeser polanya. Jadi disini
 P[saya] == P[j]
 Tetapi
 P[i-1] != p[j-1]
 jadi kita mengubah pola dari
 i ke j
 . Jadi
 shift[j] = j-i
 adalah perekam untuk
 J
 . Jadi kapan pun terjadi ketidaksesuaian pada posisi
 J
 kita akan mengubah polanya
 pergeseran[j+1]
 posisi ke kanan. Dalam kode di atas kondisi berikut ini sangat penting –

 Kondisi ini menghalangi modifikasi

 pergeseran[j]
 nilai dari akhiran yang memiliki batas yang sama. Misalnya, Pertimbangkan pola
 P = “tambahkanddcdd”
 , ketika kita menghitung bpos[ i-1 ] untuk i = 4 maka j = 7 dalam kasus ini. pada
akhirnya kita akan menetapkan nilai shift[ 7 ] = 3. Sekarang jika kita menghitung
bpos[ i-1 ] untuk i = 1 maka j = 7 dan kita akan menetapkan nilai shift[ 7 ] = 6 lagi jika
 tidak ada tes shift[ j ] == 0. Artinya jika ada ketidaksesuaian pada posisi 6 kita akan
menggeser posisi pola P 3 ke kanan, bukan posisi 6.
2) Pemrosesan awal untuk Kasus 2
Dalam preprocessing untuk kasus 2, untuk setiap akhiran
batas terluas dari keseluruhan pola
yang terkandung dalam sufiks itu ditentukan. Posisi awal dari batas terluas pola disimpan
bpos[0]
Dalam algoritma pra-pemrosesan berikut, nilai bpos[0] ini awalnya disimpan di semua entri
bebas pergeseran array. Namun ketika akhiran pola menjadi lebih pendek dari bpos[0],
algoritme melanjutkan ke batas pola berikutnya yang lebih lebar, yaitu dengan bpos[j].
Berikut adalah implementasi algoritma pencarian:
/* C++ program for Boyer Moore Algorithm with
Good Suffix heuristic to find pattern in
given text string */
#include <stdio.h>
#include <string.h>
// preprocessing for strong good suffix rule
void preprocess_strong_suffix(int *shift, int *bpos,
char *pat, int m)
{
// m is the length of pattern
int i=m, j=m+1;
bpos[i]=j;

while(i>0)
{
/*if character at position i-1 is not equivalent to
character at j-1, then continue searching to right
of the pattern for border */
while(j<=m && pat[i-1] != pat[j-1])
{
 /* the character preceding the occurrence of t in
pattern P is different than the mismatching character in P,
we stop skipping the occurrences and shift the pattern
from i to j */
if (shift[j]==0)
shift[j] = j-i;

//Update the position of next border

j = bpos[j];
}
/* p[i-1] matched with p[j-1], border is found.
store the beginning position of border */
i--;j--;
bpos[i] = j;
}
}

//Preprocessing for case 2

void preprocess_case2(int *shift, int *bpos,
char *pat, int m)
{
int i, j;
j = bpos[0];
for(i=0; i<=m; i++)
{
/* set the border position of the first character of the pattern
to all indices in array shift having shift[i] = 0 */
if(shift[i]==0)
shift[i] = j;
 /* suffix becomes shorter than bpos[0], use the position of
next widest border as value of j */
if (i==j)
j = bpos[j];
}
}

/*Search for a pattern in given text using

Boyer Moore algorithm with Good suffix rule */
void search(char *text, char *pat)
{
// s is shift of the pattern with respect to text
int s=0, j;
int m = strlen(pat);
int n = strlen(text);

int bpos[m+1], shift[m+1];

//initialize all occurrence of shift to 0

for(int i=0;i<m+1;i++) shift[i]=0;

//do preprocessing
preprocess_strong_suffix(shift, bpos, pat, m);
preprocess_case2(shift, bpos, pat, m);

while(s <= n-m)

{
 j = m-1;

/* Keep reducing index j of pattern while characters of

pattern and text are matching at this shift s*/
while(j >= 0 && pat[j] == text[s+j])
j--;

/* If the pattern is present at the current shift, then index j

will become -1 after the above loop */
if (j<0)
{
printf("pattern occurs at shift = %d\n", s);
s += shift[0];
}
else
/*pat[i] != pat[s+j] so shift the pattern
shift[j+1] times */
s += shift[j+1];
}

//Driver
int main()
{
char text[] = "ABAAAABAACD";
char pat[] = "ABA";
search(text, pat);
return 0;
}

 Output

https://www.geeksforgeeks.org/boyer-moore-algorithm-good-suffix-heuristic/

Algoritme Boyer-Moore adalah salah satu algoritme pencarian string, dipublikasikan

oleh Robert S. Boyer, dan J. Strother Moore pada tahun 1977.
Algoritme ini dianggap sebagai algoritme yang paling efisien pada aplikasi umum.[1] Tidak
seperti algoritme pencarian string yang ditemukan sebelumnya, algoritme Boyer-Moore
mulai mencocokkan karakter dari sebelah kanan pattern. Ide di balik algoritme ini adalah
bahwa dengan memulai pencocokan karakter dari kanan, dan bukan dari kiri, maka akan
lebih banyak informasi yang didapat. Langkah-langkah umum dalam mengemplementasikan
penerapan algoritma Boyer-Moore melibatkan:
1. Inisialisasi Tabel Last Occurrence:

 Buat dan inisialisasi tabel last occurrence untuk setiap karakter dalam pola
pencarian. Tabel ini memetakan setiap karakter ke indeks terakhir kemunculannya
dalam pola.
2. Pencarian Mundur :

 Mulailah pencarian dari ujung pola dan cocokkan karakter pola dengan karakter teks
dari belakang ke depan.
3. Pencarian Utama:

 Selama pencarian mundur, lakukan pergeseran dan penyesuaian berdasarkan

karakter terakhir yang tidak cocok dalam tabel last occurrence. Ini memungkinkan
untuk melompati sejumlah karakter saat tidak cocok.
4. Penanganan Hasil Pencarian:

 Jika indeks pola mencapai 0, pola ditemukan dalam teks pada posisi tertentu. Tangani
hasil pencarian sesuai kebutuhan, misalnya, cetak indeks atau lakukan Tindakan lain.
5. Optimasi dan penyesuaian Tambahan:

 Terapkan optimisasi tambahan atau penyesuaian berdasarkan karakteristik data atau

kasus khusus untuk meningkatkan efesiensi algoritma.
6. Penerapan dalam Kode Program:

 Terjemahkan langkah-langkah algoritma pada ke dalam kode program. Ini melibatkan

penggunaan struktur data, logika kontrol alur, dan manipulasi string atau array.
7. Uji dan Evaluasi:

 Uji algoritma pada berbagai jenis teks dan pola untuk memastikan keakuratannya
dan kinerjanya. Evaluasi hasil dan lakukan penyesuaian jika diperlukan.

Cara Kerja Algoritma Boyer-Moore

Misalnya ada sebuah usaha pencocokan yang terjadi pada teks[i..i+n-1], dan dianggap
ketidakcocokkan pertama terjadi diantara teks[i+j] dan patterns[i], dengan 0 < j < n. Berarti,

Teks[1+j+1..i+n-1]=patterns[j+1..n-1] Dan a= teks[1+j] tidak sama dengan b= pattern [j]. Jika u adalah
akhiran dari pattern sebelum b dan v adalah sebuah awalan dari pattern, maka penggeseran-penggeseran
yang mungkin adalah:

1, Penggeseran good-suffix yang terdiri dari menyejajarkan potongan teks [i+j+1..i+n-1]=

pattern [j+1..n-1] dengan kemunculannya paling kanan di pattern yang didahului oleh karakter
yang berbeda dengan pattern[j]. Jika tidak ada potongan seperti itu, maka algoritme akan
menyejajarkan akhiran dari v dari teks[i+j+1..i+n-1] dengan awalan dari pattern yang sama.

2. Penggeseran bad-character yang terdiri dari menyejajarkan teks [i+j] dengan kemunculan
paling kanan karakter tersebut di pattern. Bila karakter tersebut tidak ada di pattern, maka
pattern akan disejajarkan dengan teks[i+n+1].
Secara sistematis, langkah-langkah yang dilakukan algoritme Boyer-Moore pada saat
mencocokkan string adalah:

1. Algoritme Boyer-Moore mulai mencocokkan pattern pada awal teks.

2. Dari kanan ke kiri, algoritme ini akan mencocokkan karakter per karakter
pattern dengan karakter di teks yang bersesuaian, sampai salah satu kondisi
berikut dipenuhi:
1. Karakter di pattern dan di teks yang dibandingkan tidak cocok
(mismatch).
2. Semua karakter di pattern cocok. Kemudian algoritme akan
memberitahukan penemuan di posisi ini.
3. Algoritme kemudian menggeser pattern dengan memaksimalkan nilai
penggeseran good-suffix dan penggeseran bad-character, lalu mengulangi
langkah 2 sampai pattern berada di ujung teks.
Psuedcode
Berikut adalah pseudocode algoritme Boyer-Moore pada fase pra-pencarian:
Dan berikut adalah pseudocode algoritme Boyer-Moore pada fase pencarian:

http://www.iti.fh-flensburg.de/lang/algorithmen/pattern/bmen.htm

Source Code untuk algoritma Boyer-Moore

Menggunakan C++:

#include <iostream>
#include <unordered_map>
int boyerMooreSearch(const std::string& text, const std::string& pattern) {
int m = pattern.length();
int n = text.length();
std::unordered_map<char, int> lastOccurrence;
// Inisialisasi tabel last occurrence
for (int i = 0; i < m; ++i) {
lastOccurrence[pattern[i]] = i;
}
int i = m - 1; // Pointer pada pattern
int j = m - 1; // Pointer pada text
while (j < n) {
if (pattern[i] == text[j]) {
if (i == 0) {
 return j; // Pattern ditemukan
} else {
--i;
--j;
}
} else {
if (lastOccurrence.find(text[j]) != lastOccurrence.end()) {
j = j + m - std::min(i, 1 + lastOccurrence[text[j]]);
} else {
j = j + m;
}
i = m - 1;
}
}
return -1; // Pattern tidak ditemukan
}
int main() {
std::string text = "aku punya apel dan pisang.";
std::string pattern = "apel";
int result = boyerMooreSearch(text, pattern);
if (result != -1) {
std::cout << "Pattern ditemukan pada indeks: " << result << std::endl;
} else {
std::cout << "Pattern tidak ditemukan." << std::endl;
}
return 0;
}

Hasil Source Code Implementasi Penerapan Algoritma Boyer-Moore pada C++: