عرض مصدر Algorithms/Recursion

<noinclude>{{DISPLAYTITLE:التعاود}}</noinclude>
تسمى العملية التي تستدعي الدالة فيها نفسها استدعاءً مباشرًا أو غير مباشر بالتعاود recursion، وتسمى هذه الدالة بالدالة التعاودية recursive function. يمكن إيجاد الحلول لبعض المسائل بسهولة كبيرة باستخدام خوارزمية التعاود، منها على سبيل المثال: [[Algorithms/Towers of Hanoi|أبراج هانوي Towers of Hanoi]]، [[Algorithms/binary trees#.D8.A7.D9.84.D8.AA.D9.86.D9.82.D9.84 .D8.A7.D9.84.D9.88.D8.B3.D8.B7.D9.8A|التنقل الوسطي Inorder]]، و<nowiki/>[[Algorithms/binary trees#.D8.A7.D9.84.D8.AA.D9.86.D9.82.D9.84 .D8.A7.D9.84.D9.82.D8.A8.D9.84.D9.8A|التنقل القبلي Preorder]]، و<nowiki/>[[Algorithms/binary trees#.D8.A7.D9.84.D8.AA.D9.86.D9.82.D9.84 .D8.A7.D9.84.D8.A8.D8.B9.D8.AF.D9.8A|التنقل البعدي Postorder]] في عمليات التنقل عبر عناصر أشجار البيانات Tree Traversals، و<nowiki/>[[Algorithms/graphs#.D8.A7.D9.84.D8.A8.D8.AD.D8.AB .D8.A8.D8.A7.D9.84.D8.B9.D9.85.D9.82 .D8.A3.D9.88.D9.84.D9.8B.D8.A7 .D9.81.D9.8A .D8.A7.D9.84.D8.B1.D8.B3.D9.88.D9.85 .D8.A7.D9.84.D8.A8.D9.8A.D8.A7.D9.86.D9.8A.D8.A9|خوارزمية البحث بالعمق أولًا]] في [[Algorithms/graphs|الرسوم البيانية]] وغيرها.

تقدم البرامج التعاودية حلًّا للحالة الأساس Base Case ويُعرض الحل للمسألة الأكبر على هيئة مسائل أصغر.

<source lang="c++">int fact(int n)
{
    if (n < = 1) // الحالة الأساس
        return 1;
    else    
        return n*fact(n-1);    
}</source>
الحالة الأساس في المثال السابق هي <code>n <= 1</code>، ويمكن إيجاد الحل لأرقام أكبر عن طريق تحويل القيم إلى قيم أصغر إلى حين الوصول إلى الحالة الأساس.

== استخدام التعاود لحل المسائل ==

تتلخّص فكرة التعاود في تمثيل المسألة على هيئة مسألة أو مسائل أصغر، وإضافة حالة واحدة أو حالات أساس متعددة لإيقاف التعاود. فعلى سبيل المثال، يمكن حساب مضروب العدد <code>n</code> إن كان مضروب العدد <code>n-1</code> معروفًا، فتكون الحالة الأساس لعملية إيجاد المضروب هي <code>n = 0</code>؛ لذا نعيد القيمة <code>1</code> عندما تصبح <code>n=0</code>.

== حالة فيضان الكدس ==

إن لم تصل الدالة إلى الحالة الأساس أو إن كانت الحالة الأساس غير معرفة، فإنّ ذلك سيؤدي إلى حدوث حالة تسمى بفيضان الكدس Stack Overflow. مثال:

<source lang="c++">int fact(int n)
{
    // حالة أساس خاطئة (قد تتسبب في حدوث فيضان الكدس)
    if (n == 100) 
        return 1;

    else
        return n*fact(n-1);
}</source>
يؤدي استدعاء الدالة <code>fact(10)‎</code> إلى استدعاء الدوال <code>fact(9)‎</code> و <code>fact(8)‎</code> و <code>fact(7)‎</code> وهكذا، ولن تصل الدالة إلى العدد <code>100</code>، وهذا يعني عدم الوصول إلى الحالة الأساس، وإن استنزفت الذاكرة جرّاء استدعاء هذه الدوال في مكدس استدعاء الدوال، فإنّ ذلك سيتسبب في حدوث خطأ فيضان المكدس.

== التعاود المباشر والتعاود غير المباشر ==

نقول أن الدالة تعاودية مباشرة إذا كانت تستدعي نفسها. ونقول أن الدالة تعاودية غير مباشرة إذا كانت الدالة تستدعي دالة أخرى وكانت تلك الدالة الأخرى تستدعي الدالة الأولى استدعاءً مباشرًا أو غير مباشر. 

مثال:

<source lang="c++">// دالة تعاودية مباشرة
void directRecFun()
{
    // Some code....

    directRecFun();

    // Some code...
}

// دالة تعاودية غير مباشرة
void indirectRecFun1()
{
    // Some code...

    indirectRecFun2();

    // Some code...
}


// دالة تعاودية غير مباشرة
void indirectRecFun2()
{
    // Some code...

    indirectRecFun1();

    // Some code...
}
</source>
== الدالة التعاودية المذيلة وغير المذيلة ==

تكون الدالة التعاودية مذيلة tail-recursion إن كان الاستدعاء التعاودي هو آخر ما تنفّذه الدالة. 

<source lang="c++">void print(int n) 
{ 
	if (n < 0) return; 
	cout << " " << n; 

	// آخر عبارة تنفّذها الدالة هي الاستدعاء التعاودي
	print(n-1); 
} </source>
تعدّ الدوال التعاودية المذيّلة أفضل من تلك غير المذيلة، وذلك لإمكانية تحسين التعاود المذيّل بواسطة المصرّف compiler. وتقوم الفكرة على مبدأ بسيط مفاده أنّه لمّا كان الاستدعاء التعاودي في نهاية الدالة، فهذا يعني أنّه لم يبق شيء يمكن القيام به في هذه الدالة؛ ولا حاجة حينئذٍ لحفظ إطار التعاود الحالي current function's stack frame الخاص بالدالة.

=== تحويل الدالة التعاودية غير المذيلة إلى مذيلة ===

تحسب الدالة التالية مضروب العدد المعطى للدالة وليكن <code>n</code>. هذه الدالة دالة تعاودية غير مذيلة. صحيح أنّها قد تبدوا للوهلة الأولى مذيلة، ولكن إمعان النظر فيها يكشف عن أن الاستدعاء <code>fact(n)‎</code> يستخدم القيمة المعادة بواسطة الاستدعاء <code>fact(n-1)‎</code>، وهذا يعني أنّ الاستدعاء <code>fact(n-1)‎</code> ليس آخر ما تقوم به الدالة <code>fact(n)‎</code>.

<source lang="c++">#include<iostream> 
using namespace std; 

// fact(n) يستخدم الاستدعاء
// fact(n-1) القيمة المعادة بواسطة الاستدعاء 
// fact(n-1)‎ وهذا يعني أنّ الاستدعاء
// fact(n)‎ ليس آخر ما تقوم به الدالة

unsigned int fact(unsigned int n) 
{ 
	if (n == 0) return 1; 

	return n*fact(n-1); 
} 

// اختبار الدالة السابقة 
int main() 
{ 
	cout << fact(5); 
	return 0; 
} </source>
* بايثون:

<source lang="python"># fact(n) يستخدم الاستدعاء
# fact(n-1) القيمة المعادة بواسطة الاستدعاء 
# fact(n-1)‎ وهذا يعني أنّ الاستدعاء
# fact(n)‎ ليس آخر ما تقوم به الدالة

def fact(n): 

	if (n == 0): 
		return 1

	return n * fact(n-1) 

# اختبار الدالة السابقة
print(fact(5)) </source>
* جافا:

<source lang="java">class GFG { 
	
	// fact(n) يستخدم الاستدعاء
	// fact(n-1) القيمة المعادة بواسطة الاستدعاء 
	// fact(n-1)‎ وهذا يعني أنّ الاستدعاء
	// fact(n)‎ ليس آخر ما تقوم به الدالة

	static int fact(int n) 
	{ 
		if (n == 0) return 1; 
	
		return n*fact(n-1); 
	} 
	
	// اختبار الدالة السابقة
	public static void main(String[] args) 
	{ 
		System.out.println(fact(5)); 
	} 
} 
</source>
يمكن كتابة الدالة أعلاه بطريقة تجعلها دالة تعاودية مذيلة. يمكن استخدام معامل واحد أو أكثر وتجميع قيمة المضروب في المعامل الثاني، وعندما تصل قيمة <code>n</code> إلى <code>0</code>، تعيد الدالة القيمة المجمّعة.

* C++‎:

<source lang="c++">#include<iostream> 
using namespace std; 

unsigned factTR(unsigned int n, unsigned int a) 
{ 
	if (n == 0) return a; 

	return factTR(n-1, n*a); 
} 

// facTR دالة تغليف للدالة 
unsigned int fact(unsigned int n) 
{ 
return factTR(n, 1); 
} 

// اختبار الدوال السابقة
int main() 
{ 
	cout << fact(5); 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def factTR(n, a): 

	if (n == 0): 
		return a 

	return factTR(n - 1, n * a) 

# facTR دالة تغليف للدالة  
def fact(n): 
	return factTR(n, 1) 

# اختبار الدالة السابقة 
print(fact(5)) 

</source>
* جافا:

<source lang="java">class GFG { 
	
	static int factTR(int n, int a) 
	{ 
		if (n == 0) 
			return a; 
	
		return factTR(n - 1, n * a); 
	} 
	
	// factTR دالة تغليف للدالة
	static int fact(int n) 
	{ 
		return factTR(n, 1); 
	} 

	// اختبار الدالة السابقة
	static public void main (String[] args) 
	{ 
		System.out.println(fact(5)); 
	} 
} 
</source>
== حجز الذاكرة للدوال التعاودية ==

عند استدعاء الدالة من الدالة الرئيسية <code>main()‎</code> يُحجز مقدار من الذاكرة في المكدس، وعندما تستدعي الدالة التعاودية نفسها يُحجز مقدار آخر من الذاكر فوق المقدار المحجوز أصلًا للدالة المستدعية وتُنشئ نسخة مختلفة من المتغيرات المحلية لكل استدعاء. وعند الوصول إلى الحالة الأساس، تعيد الدالة قيمتها إلى الدالة التي استدعتها، ويتم التخلص من الذاكرة المحجوزة وتستمر العملية.

== أمثلة ==

تعرض الأمثلة التالية طريقة إنشاء الدوال التعاودية في عدد من لغات البرمجة:

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

void printFun(int test) 
{ 
	if (test < 1) 
		return; 
	else
	{ 
		cout << test << " "; 
		printFun(test-1); // العبارة 2 
		cout << test << " "; 
		return; 
	} 
} 

int main() 
{ 
	int test = 3; 
	printFun(test); 
} 
</source>
* بايثون:

<source lang="python">def printFun(test): 

	if (test < 1): 
		return
	else: 
	
		print( test,end = " ") 
		printFun(test-1) # العبارة 2 
		print( test,end = " ") 
		return
	

test = 3
printFun(test) 
</source>
* جافا:

<source lang="java">class GFG{ 
static void printFun(int test) 
{ 
	if (test < 1) 
		return; 
	else
	{ 
		System.out.printf("%d ",test); 
		printFun(test-1); // العبارة 2 
		System.out.printf("%d ",test); 
		return; 
	} 
} 

public static void main(String[] args) 
{ 
	int test = 3; 
	printFun(test); 
} 
} </source>
يُحجز مقدار من الذاكرة عند استدعاء الدالة <code>printFun(3)‎</code> ويهيّئ المتغيّر المحلي <code>test</code> ليأخذ القيمة <code>3</code> ويضاف التعبيران 1 و 4 إلى المكدس، وتطبع الدالة القيمة <code>3</code> في البداية. في العبارة 2، تستدعى الدالة <code>printFun(2)‎</code> ويحجز مقدار من الذاكرة لهذه الدالة ويهيئ المتغير المحلي <code>test</code>إلى القيمة 12 وتضاف العبارتان 1 و 4 إلى المكدس. وبنفس الطريقة تستدعي الدالة <code>printFun(2)‎</code> الدالة <code>printFun(1)‎</code> وتستدعي الأخيرة الدالة <code>prinFun(0)‎</code>.

تصل الدالة <code>printFun(0)‎</code> في عملها إلى عبارة <code>if</code> الشرطية وتعود إلى الدالة <code>printFun(1)‎</code> ثم تنفّذ بقية العبارات في الدالة <code>printFun(1)‎</code> لتعود الدالة بعدها إلى الدالة <code>printFun(2)‎</code> وهكذا. تطبع الدالة في المخرجات الأعداد من <code>3</code> إلى <code>1</code> ثم تطبع الأعداد <code>1</code> إلى <code>3</code>.

== مساوئ التعاود ومميزاته ==

يمكن حلّ المسائل بالطريقتين التكرارية iterative والتعاودية؛ بمعنى أنّه يمكن تحويل أي برنامج مكتوب بطريقة تعاودية إلى برنامج مكتوب بطريقة تكرارية، والعكس صحيح كذلك. ولكن البرنامج التعاودي يستهلك مساحة أكبر من البرنامج التكراري، وذلك لأنّ جميع الدوال ستبقى في المكدس إلى حين الوصول إلى الحالة الأساس. كذلك يتطلب البرنامج التعاودي زمنًا أطول في التنفيذ وذلك بسبب استدعاء الدالة مرة بعد أخرى ثم العودة إلى البداية من جديد.

ولكن تقدّم الطريقة التعاودية أسلوبًا بسيطًا وواضحًا لكتابة الشيفرة. تكون بعض المسائل مسائل تعاودية في الأصل، كما هو الحال في عملية التنقل عبر عناصر الشجرة tree traversal، وخوارزمية [[Algorithms/Towers of Hanoi|أبراج هانوي]]، وغيرها. ويُفضل استخدام الشيفرة التعاودية لحلّ مثل هذه المسائل. ويجدر التنبيه إلى أنّ بالإمكان حل هذه المسائل باستخدام الطريقة التكرارية وبالاستعانة [[Algorithms/stacks|بمكدس البيانات]].

== مصادر ==

* صفحة [https://www.geeksforgeeks.org/recursion/ Recursion] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/tail-recursion/ Tail Recursion] في توثيق الخوارزميات في موقع GeeksforGeeks.

[[تصنيف: الخوارزميات]]