نمایش مبدأ برای بازگشت (علوم رایانه)

{{تغییرمسیر|تابع بازگشتی|مفهومی در ریاضیات|رابطه بازگشتی}}
{{شیوه‌های برنامه‌نویسی}}
'''بازگشت''' {{به انگلیسی|Recursion}} در [[علوم رایانه]]، روشی برای حل یک مسئله است که در آن راه‌حل مسئله به راه‌حل هایی در نمونه های کوچکتر از همان مساله وابسته می باشد<ref>{{cite book|last=Graham|first=Ronald|first2=Donald|last2=Knuth|first3=Oren|last3=Patashnik|title=Concrete Mathematics|year=1990|isbn=0-201-55802-5|chapter-url=http://www-cs-faculty.stanford.edu/~knuth/gkp.html|ref=harv|chapter=1: Recurrent Problems|access-date=۱۵ مه ۲۰۰۹|archive-date=۶ نوامبر ۲۰۲۰|archive-url=https://web.archive.org/web/20201106232418/http://www-cs-faculty.stanford.edu/~knuth/gkp.html|url-status=dead}}</ref>.

به نظر می‌رسد ترجمه «بازگشت» بیشتر مناسب کلمه انگلیسی Return باشد تا کلمه Recursion ؛ به همین دلیل بعضی از اساتید عبارت «توابع خوداتکاء» را برای نامیدن این‌گونه توابع به کار می‌برند.
همچنین از آنجایی که ریشهٔ این کلمه در زبان انگلیسی فعل Recur به معنای "اتفاق افتادن مجدد" می‌باشد  ترجمه‌های مناسب دیگر می توانند "توابع بازوقوع" و "توابع بازفراخوانی شونده" باشند، که همگی قطعا بهتر از ترجمهٔ مشهور و ضعیف آن(توابع بازگشتی) می‌باشند.
به هر حال، نگرش خوداتکاء یا بازگشتی در [[علم کامپیوتر]] یک روش فکر کردن برای حل مسائل است. در واقع خوداتکایی یا بازگشت یکی از ایده‌های اصلی علم کامپیوتر است.<ref>{{یادکرد|فصل= |کتاب=Discrete Mathematics with Applications|ناشر= |شهر= |کوشش=   |ویرایش= 2nd  |سال= 1995 |شابک=  |نویسنده=Epp, {{چر}}Susanna |نویسندگان سایر بخش‌ها=|ترجمه=|صفحه= 427 |زبان=en |مقاله= |ژورنال= |نشریه= |تاریخ= |دوره= |شماره= |شاپا=}}</ref> حل یک مسئله به روش خوداتکاء/بازگشتی بدین معناست که راه حل بستگی به مدل کوچکتری از صورت مسئله داشته باشد.<ref>{{یادکرد |فصل=  |عنوان= Concrete Mathematics |پیوند= http://www-cs-faculty.stanford.edu/~knuth/gkp.html |ناشر=  |شهر=  |کوشش=  |ویرایش=  |سال= 1990 |شابک=  |نویسنده= Graham, {{چر}}Ronald |نویسندگان سایر بخش‌ها= Donald Knuth, Oren Patashnik |ترجمه=  |صفحه= Chapter 1: Recurrent Problems |زبان= en |مقاله=  |ژورنال=  |نشریه=  |تاریخ=  |دوره=  |شماره=  |شاپا=  |access-date= ۱۵ مه ۲۰۰۹ |archive-date= ۶ نوامبر ۲۰۲۰ |archive-url= https://web.archive.org/web/20201106232418/http://www-cs-faculty.stanford.edu/~knuth/gkp.html |url-status= dead }}</ref>

<blockquote>"قدرت بازگشت قطعاً در این نهفته‌است که دسته‌ای نامتناهی از اشیا را بوسیلهٔ یک عبارت متناهی تعریف می‌کند. به معنای دیگر یک عدد نامتناهی در محاسبات می‌تواند بوسیلهٔ یک برنامهٔ متناهی بازگشتی تعریف شود حتی اگر این برنامه هیچ تکرار واضحی نداشته باشد ".<ref>{{یادکرد|فصل= |کتاب=Algorithms + Data Structures = Programs|ناشر= Prentice-Hall|شهر= |کوشش=   |ویرایش=   |سال= 1976 |شابک=  |نویسنده=Wirth, {{چر}}Niklaus |نویسندگان سایر بخش‌ها=|ترجمه=|صفحه= 126 |زبان=en |مقاله= |ژورنال= |نشریه= |تاریخ= |دوره= |شماره= |شاپا=}}</ref>
</blockquote>
اکثر [[زبان‌های برنامه نویسی]] سطح بالا عمل بازگشت را به این صورت تعریف می‌کنند که یک تابع خودش را فراخوانی کند. [[برنامه‌نویسی دستوری|زبان‌های دستوری]] ساختارهای حلقه‌ای مثل <code>while</code> یا <code>for</code> را برای انجام کارهای تکراری به کار می‌گیرند. بعضی از [[برنامه‌نویسی تابعی|زبان‌های تابعی]] هیچ ساختار حلقه‌ای تعریف نمی‌کنند اما بر خود بازگشت تکیه دارند که کد را به‌طور مکرر فراخوانی کند. [[نظریه رایانش‌پذیری|نظریهٔ رایانش‌پذیری]] ثابت کرده‌است که این زبان‌های فقط بازگشتی از نظر ریاضی برابر زبان‌های دستوری هستند، یعنی اینکه مسائل را بدون نیاز به <code>while</code> و <code>for</code> حل می‌کنند.

== الگوریتم‌های بازگشتی ==
در [[ریاضیات کاربردی]] و به خصوص کامپیوتر، مسائل فراوانی وجود دارد که حل آن‌ها را به سادگی می‌توان به صورت یک الگوریتم بازگشتی نشان داد. یک الگوریتم بازگشتی مانند یک تابع یا یک دنباله بازگشتی تعریف می‌شود فرمان‌های الگوریتم به‌طور مکرر و با پارامترهای مختلف اجرا می‌شوند تا به فرمان بنیادی الگوریتم برسیم. آنگاه تمام مقادیری را که محاسبهٔ آن‌ها انجام نشده‌است را به صورت بازگشتی محاسبه می‌نماییم تا فرمان مورد نظر اجرا شود.
یک روش متداول برای آسان‌سازی مسائل این است که آن‌ها را به زیر مسائلی از همان نوع تقسیم بندی کنیم. این روش با نام گویشی کردن شناخته می‌شود. به عنوان یک تکنیک [[برنامه نویسی]] کامپیوتر، به این روش تقسیم و غلبه {{به انگلیسی|Divide and Conquer}} گفته می‌شود. و کلید راه حل تعداد زیادی از مسائل کامپیوتری مهم است و یک بخش اساسی می‌باشد.
تمام زبان‌های برنامه‌نویسی که امروز مورد استفاده‌اند تعریفی مستقیم از توابع بازگشتی در خود دارند. وقتی چنین تابعی فراخوانی می‌شود، کامپیوتر(برای اکثر زبان‌هایی که پشته دارند) یا خود [[کد زبان]] instanceهای مختلف تابع را (با [[فراخوانی پشته]]، هر چند روش‌های دیگر هم مورد استفاده قرار می‌گیرند). برعکس آن همهٔ توابع بازگشتی می‌توانند به کمک پشته به یک تابع غیر بازگشتی تبدیل شوند. اکثر توابع و روش‌هایی که می‌توانند بوسیلهٔ کامپیوتر ارزشیابی شوند بدون استفاده از غیر بازگشتی کردن قابل بازگشتی شدن هستند.
== برنامه‌نویسی بازگشتی ==
بعضاً الگوریتم‌های بازگشتی را می‌توان به کمک زبان‌های برنامه‌نویسی پیاده‌سازی کرد که به این برنامه‌ها برنامه‌های بازگشتی گفته می‌شود. مانند [[الگوریتم‌های مرتب سازی]]، فاکتوریل، یافتن ب.م.م، و .... . در زیر به چند نمونه از برنامه‌های بازگشتی معروف اشاره می‌کنیم:
=== نمونه‌های برنامه‌های بازگشتی ===
==== فاکتوریل ====
یک مثال متداول برای برنامه‌های بازگشتی، محاسبهٔ [[فاکتوریل]] برای [[عدد طبیعی|اعداد طبیعی]] است:<div dir="ltr">
:<math> \operatorname{fact}(n) =
 \begin{cases}
 1 & \mbox{if } n = 0 \\
 n \cdot \operatorname{fact}(n-1) & \mbox{if } n> 0 \\
 \end{cases}
</math>
</div>
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">[[شبه کد]] (بازگشتی):</div>
|-
|
 '''function''' factorial is:{{سخ}}
 '''input''': integer ''n'' such that ''n''>= 0{{سخ}}
 '''output''': [''n'' × (''n''-1) × (''n''-2) × … × 1]
{{سخ}}
     1. if ''n'' is 0, '''return''' 1
     2. otherwise, '''return''' [ ''n'' × factorial(''n''-1) ]
{{سخ}}
 '''end''' factorial
|}
این تابع می‌تواند به شکل یک [[رابطه بازگشتی|رابطه‌ی بازگشتی]] نیز نوشته شود:

<math>b_n = nb_{n-1}</math>

<math>b_0 = 1</math>
     
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">محاسبهٔ رابطهٔ بازگشتی برای n = 4:</div>
|-
|
 b<sub>4</sub>           = 4 * b<sub>3</sub>{{سخ}}
              = 4 * 3 * b<sub>2</sub>
              = 4 * 3 * 2 * b<sub>1</sub>
              = 4 * 3 * 2 * 1 * b<sub>0</sub>
              = 4 * 3 * 2 * 1 * 1
              = 4 * 3 * 2 * 1
              = 4 * 3 * 2
              = 4 * 6
              = 24
|}
این الگوریتم هم مانند الگوریتم‌های دیگر به صورت غیر بازگشتی هم نوشته می‌شود.
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">[[شبه کد]] (غیر بازگشتی):</div>
|-
|
 '''function''' factorial is:{{سخ}}
 '''input''': integer ''n'' such that ''n''>= 0{{سخ}}
 '''output''': [''n'' × (''n''-1) × (''n''-2) × … × 1]
{{سخ}}
     1. '''create''' new variable called ''running_total'' with a value of 1
{{سخ}}
     2. '''begin''' loop
           1. if ''n'' is 0, '''exit''' loop
           2. '''set''' ''running_total'' to (''running_total'' × ''n'')
           3. '''decrement''' ''n''
           4. '''repeat''' loop
{{سخ}}
     3. '''return''' ''running_total''
{{سخ}}
 '''end''' factorial
|}

==== فیبوناچی ====
یکی دیگر از الگوریتم‌های بازگشتی متداول الگوریتم فیبوناچی است.
'' تابع بازگشتی فیبوناچی: ''
<div dir="ltr">
<math> fib(n) =
 \begin{cases}
 1 & \mbox{if } n = 1 \\
 1 & \mbox{if } n = 2 \\
 fib(n-1) + fib(n-2) & \mbox{if } n> 2  \\
 \end{cases}
</math>
</div>

{| class="wikitable" dir="ltr"
|-
! <div dir="rtl"> [[شبه کد]] </div>
|-
|
 '''function''' fib is:
 '''input''': integer n such that n > 0
{{سخ}}
     1. if n is 1, '''return''' 1
     2. if n is 2, '''return''' 1
     3. otherwise, '''return''' [ fib(n-1) + fib(n-2) ]
{{سخ}}
 '''end''' fib
|}
و می‌توان این تابع را با رابطهٔ بازگشتی زیر نشان داد:<div dir="ltr">
<math>b_n = b_{n-1} + b_{n-2}</math>

<math>b_2 = b_1 = 1</math>
</div>
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">محاسبهٔ رابطهٔ بازگشتی برای n = 5:</div>
|-
|
   b<sub>5</sub>            = b<sub>4</sub> + b<sub>3</sub>
                 = b<sub>3</sub> + b<sub>2</sub> + b<sub>2</sub> + b<sub>1</sub>
                 = b<sub>2</sub> + b<sub>1</sub> + 1 + 1 + 1
                 = 1 + 1 + 3
                 = 5
|}
==== ب.م.م ====
[[الگوریتم اقلیدس]] که [[بزرگ‌ترین مقسوم‌علیه مشترک|بزرگترین مقسوم‌علیه مشترک]] (ب.م.م) دو عدد را محاسبه می‌کند، می‌تواند به صورت بازگشتی نوشته شود. تابع به شکل زیر تعریف می‌شود:
<div dir="ltr">
:<math> \gcd(x,y) =
 \begin{cases}
 x & \mbox{if } y = 0 \\
 \gcd(y, \operatorname{remainder}(x,y)) & \mbox{if } x \ge y \mbox{ and } y> 0 \\
 \end{cases}
</math>{{سخ}}
</div>

{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">[[شبه کد]] (بازگشتی):</div>
|-
|
 '''function''' gcd is:
 '''input''': integer ''x'', integer ''y'' such that ''x''>= ''y'' and ''y''> 0
{{سخ}}
     1. if ''y'' is 0, '''return''' ''x''
     2. otherwise, '''return''' [ gcd( ''y'', (remainder of ''x''/''y'') ) ]
{{سخ}}
 '''end''' gcd
|}
رابطهٔ بازگشتی ب.م.م به شکل زیر تعریف می‌شود، در این رابطه منظور از <math>x%y</math>، مقدار باقیمانده‌ی حاصل از  <math>x/y</math> است:<div dir="ltr">
:<math>\gcd(x,y) = \gcd(y, x \% y)</math>
:<math>\gcd(x,0) = x</math>
</div>
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">محاسبهٔ رابطهٔ بازگشتی برای x = 27 و y = 9:</div>
|-
|
 gcd(27, 9)   = gcd(9, 27 % 9)
              = gcd(9, 0)
              = 9
|-
! <div dir="rtl">محاسبهٔ رابطهٔ بازگشتی برای x = 259 و y = 111:</div>
|-
|
 gcd(259, 111)   = gcd(111, 259 % 111)
                 = gcd(111, 37)
                 = gcd(37, 0)
                 = 37
|}
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">[[شبه کد]] (غیر بازگشتی):</div>
|-
|
 '''function''' gcd is:{{سخ}}
 '''input''': integer ''x'', integer ''y'' such that ''x''>= ''y'' and ''y''> 0
{{سخ}}
     1. '''create''' new variable called ''remainder''
{{سخ}}
     2. '''begin''' loop
           1. if ''y'' is zero, '''exit''' loop
           2. '''set''' ''remainder'' to the remainder of x/y
           3. '''set''' x to y
           4. '''set''' y to ''remainder''
           5. '''repeat''' loop
{{سخ}}
     3. '''return''' ''x''
{{سخ}}
 '''end''' gcd
|}

==== [[برج هانوی|برج‌های هانوی(برج برهما)]] ====
در محوطه معبدی در آسیای دور سه میله الماسی قرار داشت که یکی از آن‌ها حاوی تعدادی قرص طلایی بود. کاهنان معبد در تلاش بودند تا قرص‌های طلائی را از آن میله به یکی دیگر از میله‌ها تحت شرایطی انتقال دهند، و باور داشتند که با تمام شدن انتقال قرص‌ها عمر جهان نیز به پایان خواهد رسید! میله اولیه ۶۴ قرص داشت، که بر روی هم به‌طور نزولی بر اساس اندازه‌شان چیده شده‌بودند.
همانند شکل سه میله داریم. یکی از میله‌ها میله مبدأ (A)، دیگری میله کمکی (B) و دیگری میله مقصد (C) است. هدف انتقال تمام دیسک‌ها از میله مبدأ به میله مقصد با رعایت شرایط زیر است:

در هر زمان فقط یک دیسک را می‌توان جابجا نمود. نباید در هیچ زمانی دیسکی بر روی دیسک با اندازه کوچکتر قرار بگیرد.
هدف ما ارائه الگوریتمی است که کمترین توالی حرکت‌ها را برای انتقال دیسک‌ها به ما بدهد. مثلاً اگر n=۲ باشد، توالی حرکت به صورت زیر است:
[[پرونده:Tower of Hanoi 4.gif|بندانگشتی|چپ|حل مسئله برج هانوی]]
* دیسک ۱ را به میله B منتقل می‌کنیم.
* دیسک ۲ را به میله C منتقل می‌کنیم.
* دیسک ۱ را به میله C منتقل می‌کنیم.
توجه داشته باشید که بر اساس قانون اول نمی‌توان به غیر از بالاترین دیسک هر میله، به دیسک دیگری از آن دسترسی پیدا کرد.

حال سؤال این است که آیا این مسئله به کمک تکنیک بازگشت قابل حل است؟ اصولاً چه مسائلی را می‌توان بازگشتی حل نمود؟

برای اینکه مسئله‌ای بتواند با روش بازگشتی حل شود باید یک ویژگی اساسی داشته باشد. مسئله اصلی (مسئله‌ای که به ما داده می‌شود) قابل خرد شدن به زیر مسئله‌هایی از همان نوع مسئله اصلی باشد، به شرطی که اندازه زیر مسئله‌های ایجاد شده کمتر باشد. آنگاه می‌توان امیدوار بود که آن را به‌طور بازگشتی حل کرد! این ویژگی در مورد مسئله [[برج هانوی]] صدق می‌کند. ایده اصلی این است که توجهمان را به جای حرکت بالاترین دیسک، روی پایین‌ترین دیسک میله متمرکز کرده، و مراحل زیر را طی می‌کنیم:

n - ۱ دیسک بالایی را با شرایط ذکر شده و به کمک میله C به میله B منتقل می‌کنیم. بزرگترین دیسک را از میله مبدأ به میله مقصد حرکت می‌دهیم. n - ۱ دیسک را که هم‌اکنون در میله B هستند با شرایط داده شده به میله مقصد انتقال می‌دهیم. می‌بینیم که توانستیم عملیات جابجا کردن n دیسک را به دو عملیات مشابه ولی با اندازه کمتر و یک عملیات ساده تقسیم کنیم. واضح است که جابجا کردن n - ۱ قرص راحتتر از جابجا نمودن n قرص است.
''تابع بازگشتی برج‌های هانوی'':
<div dir="ltr">
:<math> \operatorname{hanoi}(n) =
 \begin{cases}
 1 & \mbox{if } n = 1 \\
 2\cdot\operatorname{hanoi}(n-1) + 1 & \mbox{if } n> 1\\
 \end{cases}
</math>
</div>
''رابطهٔ بازگشتی برای هانوی'':
<div dir="ltr">
:<math>h_n = 2h_{n-1}+1</math>
:<math>h_1 = 1</math>
</div>
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">محاسبهٔ رابطهٔ بازگشتی برای n = 4:</div>
|-
|
 hanoi(4)     = 2*hanoi(3) + 1
              = 2*(2*hanoi(2) + 1) + 1
              = 2*(2*(2*hanoi(1) + 1) + 1) + 1
              = 2*(2*(2*1 + 1) + 1) + 1
              = 2*(2*(3) + 1) + 1
              = 2*(7) + 1
              = 15
|}
{| class="wikitable" dir="ltr"
|-
! <div dir="rtl">[[شبه کد]] (بازگشتی):</div>
|-
|
 '''function''' hanoi is:{{سخ}}
 '''input''': integer ''n'', such that ''n''>= ''1''
{{سخ}}
     1. '''if''' n is 1 '''then return''' 1
{{سخ}}
     2. '''return''' [2 * ['''call''' hanoi(n-1)] + 1]
{{سخ}}
 '''end''' hanoi
|}
هر چند برای تمام توابع بازگشتی راه حل روشنی نمی‌توان یافت اما برج‌های هانوی از این قاعده مستثنی است:
{| class="wikitable" dir="ltr"
|-
<div dir="rtl">راه حل مستقیم برای مسئلهٔ برج‌های هانوی:</div>
|-
|
 h<sub>1</sub> = 1   = 2<sup>1</sup> - 1
 h<sub>2</sub> = 3   = 2<sup>2</sup> - 1
 h<sub>3</sub> = 7   = 2<sup>3</sup> - 1
 h<sub>4</sub> = 15  = 2<sup>4</sup> - 1
 h<sub>5</sub> = 31  = 2<sup>5</sup> - 1
 h<sub>6</sub> = 63  = 2<sup>6</sup> - 1
 h<sub>7</sub> = 127 = 2<sup>7</sup> - 1

 In general:
 h<sub>n</sub> = 2<sup>n</sup> - 1, for all n>= 1
|}

=== ساختمان داده‌های بازگشتی(ساخت یافته) ===
در اصطلاح کامپیوتری، [[ساختمان داده]] به روشهایی از ذخیره اطلاعات گفته می‌شود که برای استفاده بهینه از اطلاعات ذخیره شده اتخاذ می‌شود. غالباً انتخاب یک ساختمان داده موجب ایجاد [[الگوریتم|الگوریتم‌های]] متناسب با آن خواهد شد که این دو در کنار هم موجب افزایش سرعت انجام یک وظیفه یا کاهش مصرف حافظه برای [[پردازش داده]] می‌شود؛ سنگ بنای ساختمان‌های داده انواع داده و اشاره گرهای گوناگون است. که با توجه به چگونگی تعریف کاربرد آن‌ها در هر [[زبان برنامه نویسی]] پیاده‌سازی آن‌ها متفاوت خواهد بود.
==== [[لیست پیوندی]] ====
در زیر می‌توانید تعریف ساده‌ای از گرهٔ فهرستهای پیوندی را مشاهده کنید. عنصر بعدی در ساختار گره اشاره گری است به یک ساختار گره.
<div dir="ltr">
<syntaxhighlight lang="C">
struct node
{
  int n;              // some data
  struct node *next;  // pointer to another struct node
};

// LIST is simply a synonym for struct node * (aka syntactic sugar).
typedef struct node *LIST;
</syntaxhighlight>
رویه‌هایی که لیست ساختمان داده را به وجود می‌آورند می‌توانند به صورت بازگشتی هم تعریف شوند.
<syntaxhighlight lang="C">
void printList(LIST lst)
{
    if (!isEmpty(lst))         // base case
    {
       printf("%d ", lst->n);  // print integer followed by a space
       printList(lst->next);   // recursive call
    }
}
</syntaxhighlight>
</div>

==== درخت‌های دودویی ====
در زیر می‌توانید تعریف ساده‌ای از درخت‌های دودویی را مشاهده کنید. همانند گره‌ها برای لیست‌های الحاقی در اینجا نیز تعریف به صورت بازگشتی است. در اینجا دو [[اشاره‌گر (علوم رایانه)|اشاره‌گر]] داریم، یکی به زیر درخت سمت چپ و دیگری به زیر درخت سمت راست.
<div dir="ltr">
<syntaxhighlight lang="C">
struct node
{
  int n;               // some data
  struct node *left;   // pointer to the left subtree
  struct node *right;  // point to the right subtree
};

// TREE is simply a synonym for struct node * (aka syntactic sugar).
typedef struct node *TREE;
</syntaxhighlight>
<syntaxhighlight lang="C">
void printTree(TREE t) {
        if (!isEmpty(t)) {            // base case                          
                printTree(t->left);   // go left
                printf("%d ", t->n);  // print the integer followed by a space
                printTree(t->right);  // go right
        }
}
</syntaxhighlight>
</div>

=== بازگشتی در مقابل غیر بازگشتی ===

دربارهٔ اینکه کدامیک سریعتر و بهینه تر است نمی‌توان نظر قطعی داد و بستگی به خود الگوریتم و دفعات اجرای آن دارد. اما در هر حال هر کدام برتری‌ها و کاستی‌های نسبت به دیگری دارد و در موارد خاصی الگوریتم‌ها فقط با یکی از این روش قابل پیاده سازی‌اند.

== ترتیب فراخوانی توابع ==
=== تابع ۱ ===
ترتیب فراخوانی توابع تأثیر به سزایی در اجرای برنامه دارد. به مثال زیر که با زبان C نوشته است، توجه کنید.
<div dir="ltr">
<syntaxhighlight lang="c">
void recursiveFunction(int num) {
   if (num <5) {
      printf("%d\n", num);
      recursiveFunction(num + 1);
   }
}
</syntaxhighlight>
</div>
[[پرونده:RecursiveFunction1 execution.png]]
=== تابع ۲ با خطوط جابجا شده ===
<div dir="ltr">
<syntaxhighlight lang="c">
void recursiveFunction(int num) {
   if (num <5) {
      recursiveFunction(num + 1);
      printf("%d\n", num);
   }
}
</syntaxhighlight>
</div>

[[پرونده:RecursiveFunction2 execution.png]]
== بازگشت مستقیم و غیرمستقیم ==
بازگشت مستقیم زمانی است که تابع خود را فراخوانی کند. بازگشت غیرمستقیم زمانی است که به‌طور مثال تابع «الف» تابع «ب» و تابع «ب« تابع «ث« و تابع «ث» نیز دوباره تابع «الف» را فراخوانی کند.

== پیوند به بیرون ==

== منابع ==
* [https://web.archive.org/web/20180425004406/http://www.pylearn.com/]
* [[ریاضیات گسسته]] و الگوریتم‌ها نوشته دکتر علی بهفروز و مهندس محمد ایزدی
{{پانویس}}

[[رده:بازگشت]]
[[رده:زیرروال‌ها]]
[[رده:علوم نظری رایانه]]
[[رده:نظریه بازگشت]]
[[رده:واژگان برنامه‌نویسی]]