عرض مصدر Algorithms/Boyer Moore

<noinclude>{{DISPLAYTITLE:خوارزمية بوير مور}}</noinclude>
تعتمد خوارزمية بوير-مور Boyer-Moore على أسلوبين أساسيين هما:

# استكشاف الحروف السيئة Bad Character Heuristic
# استكشاف اللاحقة الجيدة Good Suffix Heuristic

يمكن استخدام كل أسلوب من هذين الأسلوبين على حدة للبحث عن نمط في نص معين.

تجري خوارزمية بوير-مور معالجة مسبقة على النمط المراد البحث عنه وذلك لتحريك النمط أثناء عملية المقارنة أكثر من خطوة واحدة. تصنع خوارزمية بوير-مور مصفوفتين مختلفتين لكلا الأسلوبين. وفي كل خطوة من خطوات مطابقة النمط مع النص، تحرك الخوارزمية النمط بمقدار يساوي أعلى قيمة للتحريك يقترحها الأسلوبان الآنفا الذكر. 

تبدأ خوارزمية بوير-مور بالمطابقة من آخر حرف في النمط وذلك على عكس بقية خوارزميات البحث عن الأنماط.

== استكشاف الحروف السيئة ==

يعتمد هذا الأسلوب على فكرة بسيطة مفادها أنّ الحرف في النص والذي لا يطابق الحرف الحالي في النمط يسمّى بالحرف السيء Bad Character. وعند حدوث حالة عدم التطابق، فإنّنا نزيح النمط إلى أن يتحقق أحد الأمرين التاليين:

# تتحول حالة عدم التطابق إلى حالة تطابق.
# يتخطّى النمط P الحرف غير المطابق.

=== الحالة الأولى: تحول حالة عدم التطابق إلى حالة تطابق ===

يجري البحث في هذه الحالة عن موقع آخر ظهور للحرف غير المطابق في النمط، وإذا كان الحرف غير المطابق موجودًا في النمط فسنزيح النمط بطريقة تجعله محاذيًا للحرف غير المطابق في النص T.

يعرض الشكل التالي مثالًا عن هذه الحالة:

هناك حالة عدم تطابق في الموقع <code>3</code>، والحرف غير المطابق هنا هو <code>"A"</code>. سيجري البحث عن آخر ظهور للحرف <code>"A"</code> في النمط، وهو الموقع <code>1</code> في النمط (باللون الأزرق) وهو كذلك آخر ظهور لهذا الحرف في النمط؛ لذا سنحرّك النمط مرتين وذلك لمحاذاة الحرف <code>"A"</code> في النمط مع الحرف <code>"A"</code> في النص.

=== الحالة الثانية: تخطي النمط للحرف غير المطابق ===

يجري البحث في هذه الحالة عن موقع آخر ظهور للحرف غير المطابق في النمط، وإن لم يكن الحرف موجودًا يُزاح النمط ليتخطّى الحرف غير المطابق.

يعرض الشكل التالي مثالًا عن هذه الحالة:

هناك حالة عدم تطابق في الموقع <code>7</code>، والحرف غير المطابق هو الحرف <code>"C"</code> وهو غير موجود في النمط قبل الموقع <code>7</code>؛ لذا سيزاح النمط ليتخطّى الموقع <code>7</code>، وستظهر حالة تطابق تام في المثال أعلاه (اللون الأخضر). لاحظ أنّه لمّا كان الحرف <code>"C"</code> غائبًا عن النمط المراد البحث عنه فإنّ أي إزاحة للنمط قبل الموقع <code>7</code> ستؤدي إلى الحصول على حالة عدم تطابق وستكون عملية البحث دون فائدة.

== تنفيذ الخوارزمية ==

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من لغات البرمجة:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 
# define NO_OF_CHARS 256 

// دالة المعالجة القبلية لخوارزمية بوير-مور
// بالاعتماد على أسلوب استكشاف الحروف السيئة
void badCharHeuristic( string str, int size, 
						int badchar[NO_OF_CHARS]) 
{ 
	int i; 

	// تهيئة جميع قيم ظهور الحروف لتكون ‎-1
	for (i = 0; i < NO_OF_CHARS; i++) 
		badchar[i] = -1; 

	// تعبئة القيمة الحقيقية لآخر ظهور للحرف
	for (i = 0; i < size; i++) 
		badchar[(int) str[i]] = i; 
} 

/* دالة البحث عن النمط والتي تستخدم أسلوب
استكشاف الحروف السيئة في خوارزمية بوير-مور*/
void search( string txt, string pat) 
{ 
	int m = pat.size(); 
	int n = txt.size(); 

	int badchar[NO_OF_CHARS]; 

	/* تعبئة مصفوفة الحروف السيئة وذلك باستدعاء
	دالة المعالجة القبلية على النمط المعطى*/
	badCharHeuristic(pat, m, badchar); 

	int s = 0; // مقدار إزاحة النمط بالنسبة إلى النص 

	while(s <= (n - m)) 
	{ 
		int j = m - 1; 

		/* j الاستمرار في إنقاص الموقع
		في النمط ما دامت حروف النمط وحروف النص
		متطابقة في هذه الإزاحة */
		while(j >= 0 && pat[j] == txt[s + j]) 
			j--; 

		/* إن كان النمط موجودًا في الإزاحة الحالية
		j فهذا يعني أن الموقع
		سيصبح ‎-1 بعد هذه الحلقة */
		
		if (j < 0) 
		{ 
			cout << "pattern occurs at shift = " << s << endl; 

			/* إزاحة النمط ليحاذي الحرف التالي في النص
			آخر ظهور له في النمط. نحتاج إلى استخدام الشرط
			s+m < n
			وذلك في حالة ظهور النمط في نهاية النص */
			s += (s + m < n)? m-badchar[txt[s + m]] : 1; 

		} 

		else
		/* إزاحة النمط ليحاذي الحرف السيئ آخر ظهور له
		max في النمط. تستخدم الدالة
		لضمان الحصول على إزاحة بقيمة موجبة. إذ يمكن الحصول
		على إزاحة بقيمة سالبة إن كان آخر ظهور للحرف السيئ
		في النمط على الجهة اليمنى من الحرف الحالي */
			s += max(1, j - badchar[txt[s + j]]); 
	} 
} 

/* اختبار الدوال السابقة */
int main() 
{ 
	string txt= "ABAAABCD"; 
	string pat = "ABC"; 
	search(txt, pat); 
	return 0; 
} </source>
* بايثون:

<source lang="python">NO_OF_CHARS = 256

def badCharHeuristic(string, size): 
	''' 
	دالة المعالجة القبلية لخوارزمية بوير-مور 
	بالاعتماد على أسلوب استكشاف الحروف السيئة 
	'''

	# تهيئة جميع قيم ظهور الحروف لتكون ‎-1 
	badChar = [-1]*NO_OF_CHARS 

	# تعبئة القيمة الحقيقية لآخر ظهور للحرف 
	for i in range(size): 
		badChar[ord(string[i])] = i; 

	# إعادة القائمة المهيئة
	return badChar 

def search(txt, pat): 
	''' 
	دالة البحث عن النمط والتي تستخدم أسلوب 
	استكشاف الحروف السيئة في خوارزمية بوير-مور 
	'''
	m = len(pat) 
	n = len(txt) 

	# تعبئة مصفوفة الحروف السيئة وذلك باستدعاء 
	# دالة المعالجة القبلية على النمط المعطى 
	badChar = badCharHeuristic(pat, m) 

	# مقدار إزاحة النمط بالنسبة إلى النص 
	s = 0
	while(s <= n-m): 
		j = m-1

		# j الاستمرار في إنقاص الموقع
		# في النمط ما دامت حروف النمط وحروف النص
		# متطابقة في هذه الإزاحة 
		while j>=0 and pat[j] == txt[s+j]: 
			j -= 1

		# إن كان النمط موجودًا في الإزاحة الحالية 
		# j فهذا يعني أن الموقع 
		# سيصبح ‎-1 بعد هذه الحلقة
		if j<0: 
			print("Pattern occur at shift = {}".format(s)) 

			'''	 
				إزاحة النمط ليحاذي الحرف التالي في النص 
					آخر ظهور له في النمط. نحتاج إلى استخدام الشرط
					 s+m < n
					  وذلك في حالة ظهور النمط في نهاية النص 
			'''
			s += (m-badChar[ord(txt[s+m])] if s+m<n else 1) 
		else: 
			''' 
			إزاحة النمط ليحاذي الحرف السيئ آخر ظهور له 
			max في النمط. تستخدم الدالة 
			لضمان الحصول على إزاحة بقيمة موجبة. إذ يمكن الحصول 
			على إزاحة بقيمة سالبة إن كان آخر ظهور للحرف السيئ
			في النمط على الجهة اليمنى من الحرف الحالي 
			'''
			s += max(1, j-badChar[ord(txt[s+j])]) 


# اختبار الدوال السابقة 
def main(): 
	txt = "ABAAABCD"
	pat = "ABC"
	search(txt, pat) 

if __name__ == '__main__': 
	main() </source>
* جافا:

<source lang="java">class AWQ{ 
	
	static int NO_OF_CHARS = 256; 
	
	// دالة مساعدة للحصول على العدد الأكبر من بين عددين
	static int max (int a, int b) { return (a > b)? a: b; } 

	// دالة المعالجة القبلية لخوارزمية بوير-مور
	// بالاعتماد على أسلوب استكشاف الحروف السيئة
	static void badCharHeuristic( char []str, int size,int badchar[]) 
	{ 
	int i; 

	// تهيئة جميع قيم ظهور الحروف لتكون ‎-1 
	for (i = 0; i < NO_OF_CHARS; i++) 
		badchar[i] = -1; 

	// تعبئة القيمة الحقيقية لآخر ظهور للحرف 
	for (i = 0; i < size; i++) 
		badchar[(int) str[i]] = i; 
	} 

	/* دالة البحث عن النمط والتي تستخدم أسلوب
	استكشاف الحروف السيئة في خوارزمية بوير-مور*/
	static void search( char txt[], char pat[]) 
	{ 
	int m = pat.length; 
	int n = txt.length; 

	int badchar[] = new int[NO_OF_CHARS]; 

	/* تعبئة مصفوفة الحروف السيئة وذلك باستدعاء
	دالة المعالجة القبلية على النمط المعطى*/
	badCharHeuristic(pat, m, badchar); 

	int s = 0; // مقدار إزاحة النمط بالنسبة إلى النص 
	while(s <= (n - m)) 
	{ 
		int j = m-1; 

		/* j الاستمرار في إنقاص الموقع
		في النمط ما دامت حروف النمط وحروف النص
		متطابقة في هذه الإزاحة */
		while(j >= 0 && pat[j] == txt[s+j]) 
			j--; 

		/* إن كان النمط موجودًا في الإزاحة الحالية
		j فهذا يعني أن الموقع
		سيصبح ‎-1 بعد هذه الحلقة */
		if (j < 0) 
		{ 
			System.out.println("Patterns occur at shift = " + s); 

			/* إزاحة النمط ليحاذي الحرف التالي في النص
			آخر ظهور له في النمط. نحتاج إلى استخدام الشرط
			s+m < n
			وذلك في حالة ظهور النمط في نهاية النص */
			s += (s+m < n)? m-badchar[txt[s+m]] : 1; 

		} 

		else
			/* إزاحة النمط ليحاذي الحرف السيئ آخر ظهور له
		max في النمط. تستخدم الدالة
		لضمان الحصول على إزاحة بقيمة موجبة. إذ يمكن الحصول
		على إزاحة بقيمة سالبة إن كان آخر ظهور للحرف السيئ
		في النمط على الجهة اليمنى من الحرف الحالي */
			s += max(1, j - badchar[txt[s+j]]); 
	} 
	} 

	/* اختبار الدوال السابقة */
	public static void main(String []args) { 
		
		char txt[] = "ABAAABCD".toCharArray(); 
		char pat[] = "ABC".toCharArray(); 
		search(txt, pat); 
	} 
} 
</source>
== التعقيد الزمني ==

تجري طريقة التنفيذ أعلاه معالجة قبلية للنمط وتخزّن آخر ظهور لكل حرف ممكن في مصفوفة حجمها مساوٍ لعدد الحروف الأبجدية. إن لم يكن الحرف موجودًا إطلاقًا، فإنّ هذا سيؤدي إلى إزاحة النمط بمقدار <code>m</code> (طول النمط)، وبهذا يبلغ التعقيد الزمني لأسلوب استكشاف الحروف السيئة المقدار <code>O(n/m)‎</code> في أفضل الحالات.

ولكن قد يبلغ التعقيد الزمني لهذا الأسلوب المقدار <code>O(mn)‎</code> في أسوأ الحالات والتي تكون فيها حروف النص والنمط متطابقة بالكامل، مثل: <code>txt[] = "AAAAAAAAAAAAAAAAAAA"‎</code> و<code>pat[] = "AAAAA"‎</code>.

== استكشاف اللاحقة الجيدة ==

لنفترض وجود سلسلة نصية <code>t</code> متفرعة من النصّ <code>T</code> والذي تجري مطابقته بواسطة سلسلة نصية متفرّعة من النمط <code>P</code>، ففي أسلوب الاستكشاف هذا نزيح النمط إلى أن تتحق إحدى الحالات التالية:

# تطابق ظهورٍ آخر للسلسلة النصية <code>t</code> في النمط <code>P</code> مع السلسلة النصية <code>t</code> في النصّ <code>T</code>.
# تطابق سابقة في <code>P</code> مع لاحقة من <code>t</code> في النصّ <code>T</code>.
# تخطّي <code>P</code> للسلسلة النصية <code>t</code>.

=== الحالة الأولى: تطابق ظهورٍ آخر للسلسلة النصية <code>t</code> في النمط <code>P</code> مع السلسلة النصية <code>t</code> في النصّ <code>T</code>. ===

قد يحتوي النمط <code>P</code> على حالات ظهور أخرى للسلسلة النصية <code>t</code>، وفي مثل هذه الحالة سنحاول إزاحة النمط لمحاذاة حالة الظهور تلك مع السلسلة النصية <code>t</code> في النص <code>T</code>. فعلى سبيل المثال:



توجد في المثال أعلاه سلسلة نصية <code>t</code> متفرّعة من النصّ <code>T</code> متطابقة مع النمط <code>P</code> (اللون الأخضر) قبل حالة عدم التطابق في الموقع <code>2</code>. سنبحث الآن عن ظهور للسلسلة النصية <code>t</code> (وهي <code>"AB"</code>) في النمط <code>P</code>. وقد وجدنا ظهورًا يبدأ من الموقع <code>1</code> (الخلفية الصفراء) لذا سنزيح النمط إلى اليمين مرتين لمحاذاة <code>t</code> في <code>P</code> مع <code>t</code> في <code>T</code>. هذه الطريقة ليست فعالة وسنعرض طريقة أخرى أكثر قوة فيما يلي.

=== الحالة الثانية: تطابق سابقة في <code>P</code> مع لاحقة من <code>t</code> في النص <code>T</code> ===

إن احتمال العثور على ظهور للسلسلة النصية <code>t</code> في النمط <code>P</code> ليس احتمالًا قويًا، وفي بعض الأحيان لا تظهر السلسلة النصية في النمط على الإطلاق، وفي مثل هذه الحالات يمكن البحث في بعض الأحيان عن لاحقة في <code>t</code> تطابق سابقة في <code>P</code> ومحاذاتهما معًا عن طريق إزاحة النمط <code>P</code>. فعلى سبيل المثال:



توجد في المثال أعلاه سلسلة نصية <code>t</code> (وهي <code>"BAB"</code>) مطابقة للنمط <code>P</code> (اللون الأخضر) في الموقع <code>‎2-4</code> قبل حالة عدم التطابق. ولكن لا وجود لأي ظهور للسلسلة <code>t</code> في النمط <code>P</code> ولذلك سنبحث عن سابقة في النمط <code>P</code> تطابق لاحقة في السلسلة النصية <code>t</code>. ويلاحظ أنّ السابقة <code>"AB"</code> (الخلفية الصفراء) تبدأ من الموقع <code>0</code> وتطابق اللاحقة <code>"AB"</code> في السلسلة النصية <code>t</code> في الموقع <code>3</code>. لذا سنزيح النمط <code>3</code> مرات لمحاذاة اللاحقة مع السابقة.

=== الحالة الثالثة: تخطّي <code>P</code> للسلسلة النصية <code>t</code> ===

إن لم تتحق الحالتان السابقتان، يُزاح النمط ليتخطّى السلسلة النصّية <code>t</code>، فعلى سبيل المثال:



يلاحظ عدم وجود أيّ ظهور للسلسلة النصية <code>t</code> (وهي <code>"AB"</code>) في النمط <code>P</code>، إلى جانب عدم وجود لاحقة في النمط تطابق سابقة في السلسلة النصية <code>t</code>. لهذا، لا يمكن وجود تطابق تام قبل الموقع <code>4</code>، ويُزاح النمط <code>P</code> ليتخطّى السلسلة النصّية <code>t</code> أي سينتقل النمط إلى الموقع <code>5</code>.
== مصادر ==

* صفحة [https://www.geeksforgeeks.org/boyer-moore-algorithm-for-pattern-searching/ Boyer Moore Algorithm for Pattern Searching] في توثيق الخوارزميات في موقع GeeksforGeeks.