Ce este recursiunea?
Procesul în care o funcție se numește direct sau indirect se numește recursiune, iar funcția corespunzătoare este numită funcție recursivă. Folosind un algoritm recursiv, anumite probleme pot fi rezolvate destul de ușor. Exemple de astfel de probleme sunt Turnurile din Hanoi (TOH) , Inorder/Precomanda/Postorder Tree Traversas , DFS de Graph , etc. O funcție recursivă rezolvă o anumită problemă apelând o copie a ei înșiși și rezolvând subprobleme mai mici ale problemelor originale. Multe mai multe apeluri recursive pot fi generate atunci când este necesar. Este esențial să știm că ar trebui să furnizăm un anumit caz pentru a încheia acest proces recursiv. Deci putem spune că de fiecare dată funcția se autoinvocă cu o versiune mai simplă a problemei originale.

Nevoia de recursivitate

Recursiunea este o tehnică uimitoare cu ajutorul căreia putem reduce lungimea codului nostru și îl facem mai ușor de citit și de scris. Are anumite avantaje față de tehnica de iterație care va fi discutată mai târziu. O sarcină care poate fi definită cu subsarcina similară, recursiunea este una dintre cele mai bune soluții pentru aceasta. De exemplu; Factorialul unui număr.

Proprietăți ale recursiunii:

• Efectuând aceleași operații de mai multe ori cu intrări diferite.
• În fiecare pas, încercăm intrări mai mici pentru a reduce problema.
• Condiția de bază este necesară pentru a opri recursiunea, altfel va avea loc o buclă infinită.

Algoritm: pași

The algorithmic steps for implementing recursion in a function are as follows: Step1 - Define a base case: Identify the simplest case for which the solution is known or trivial. This is the stopping condition for the recursion, as it prevents the function from infinitely calling itself. Step2 - Define a recursive case: Define the problem in terms of smaller subproblems. Break the problem down into smaller versions of itself, and call the function recursively to solve each subproblem. Step3 - Ensure the recursion terminates: Make sure that the recursive function eventually reaches the base case, and does not enter an infinite loop. step4 - Combine the solutions: Combine the solutions of the subproblems to solve the original problem.>

O interpretare matematică

Să luăm în considerare o problemă pe care o are un programator pentru a determina suma primelor n numere naturale, există mai multe moduri de a face asta, dar cea mai simplă abordare este pur și simplu să adunăm numerele începând de la 1 la n. Deci funcția arată pur și simplu așa,

abordare(1) – Pur și simplu adăugați unul câte unul

f(n) = 1 + 2 + 3 +……..+ n

dar există o altă abordare matematică a reprezentării acestui lucru,

abordare(2) – Adăugarea recursive

f(n) = 1 n=1

f(n) = n + f(n-1) n>1

Există o diferență simplă între abordarea (1) și abordarea (2) și aceasta este în abordare(2) functia f( ) însuși este numit în interiorul funcției, deci acest fenomen se numește recursivitate, iar funcția care conține recursiune se numește funcție recursivă, la sfârșit, acesta este un instrument grozav în mâna programatorilor pentru a codifica unele probleme într-un mod mult mai ușor și eficient. cale.

Cum sunt stocate funcțiile recursive în memorie?

Recursiunea folosește mai multă memorie, deoarece funcția recursivă se adaugă la stiva cu fiecare apel recursiv și păstrează valorile acolo până când apelul este terminat. Funcția recursivă folosește structura LIFO (LAST IN FIRST OUT) la fel ca structura de date a stivei. stivă-date-structură/

Care este condiția de bază în recursivitate?
În programul recursiv se oferă soluția cazului de bază, iar soluția problemei mai mari este exprimată în termeni de probleme mai mici.

int fact(int n) { if (n <= 1) // base case return 1; else return n*fact(n-1); }>

În exemplul de mai sus, cazul de bază pentru n <= 1 este definit și valoarea mai mare a unui număr poate fi rezolvată prin conversia într-unul mai mic până când este atins cazul de bază.

Cum se rezolvă o anumită problemă folosind recursiunea?
Ideea este de a reprezenta o problemă în termeni de una sau mai multe probleme mai mici și de a adăuga una sau mai multe condiții de bază care opresc recursiunea. De exemplu, calculăm factorialul n dacă cunoaștem factorialul (n-1). Cazul de bază pentru factorial ar fi n = 0. Se întoarce 1 când n = 0.

De ce apare eroarea Stack Overflow în recursivitate?
Dacă cazul de bază nu este atins sau nu este definit, atunci poate apărea problema de depășire a stivei. Să luăm un exemplu pentru a înțelege acest lucru.

int fact(int n) { // wrong base case (it may cause // stack overflow). if (n == 100) return 1; else return n*fact(n-1); }>

Dacă se apelează fact(10), se va apela fact(9), fact(8), fact(7) și așa mai departe, dar numărul nu va ajunge niciodată la 100. Deci, cazul de bază nu este atins. Dacă memoria este epuizată de aceste funcții de pe stivă, va cauza o eroare de depășire a stivei.

Care este diferența dintre recursiunea directă și indirectă?
O funcție fun este numită recursivă directă dacă numește aceeași funcție fun. O funcție fun se numește recursivă indirectă dacă apelează o altă funcție, spune fun_new și fun_new apelează direct sau indirect distracție. Diferența dintre recursiunea directă și cea indirectă a fost ilustrată în Tabelul 1.

 // An example of direct recursion void directRecFun() { // Some code.... directRecFun(); // Some code... } // An example of indirect recursion void indirectRecFun1() { // Some code... indirectRecFun2(); // Some code... } void indirectRecFun2() { // Some code... indirectRecFun1(); // Some code... }>

Care este diferența dintre recursiunea cu coadă și cea fără coadă?
O funcție recursivă este recursivă de coadă atunci când un apel recursiv este ultimul lucru executat de funcție. Vă rugăm să consultați articol recursiv tail pentru detalii.

Cum este alocată memoria diferitelor apeluri de funcții în recursivitate?
Când orice funcție este apelată din main(), memoria îi este alocată pe stivă. O funcție recursivă se autoapelează, memoria pentru o funcție apelată este alocată peste memoria alocată funcției de apelare și o copie diferită a variabilelor locale este creată pentru fiecare apel de funcție. Când este atins cazul de bază, funcția returnează valoarea acesteia funcției de către care este apelată și memoria este de-alocată și procesul continuă.
Să luăm exemplul cum funcționează recursiunea luând o funcție simplă.

CPP

>

>

Java

Seria Fibonacci în c

>

>

Python3

>

>

C#

>

>

PHP

> 
    
   
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > > // JavaScript program to demonstrate working of> // recursion> > function> printFun(test)> >{> >if> (test <1)> >return>;> >else> {> >document.write(test +>' '>);> >printFun(test - 1);>// statement 2> >document.write(test +>' '>);> >return>;> >}> >}> > // Driver code> >let test = 3;> >printFun(test);> > > 
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
3 2 1 1 2 3>
 
  Complexitatea timpului: O(1) 
  Spațiu auxiliar: O(1)
 
Când printFun(3) este apelat de la main(), memoriei este alocată printFun(3) și un test de variabilă locală este inițializat la 3 și instrucțiunile de la 1 la 4 sunt împinse pe stivă, așa cum se arată în diagrama de mai jos. Mai întâi imprimă „3”. În declarația 2, printFun(2) este apelat și memoriei este alocată printFun(2) și un test de variabilă locală este inițializat la 2 și instrucțiunile de la 1 la 4 sunt împinse în stivă. În mod similar, printFun(2) apeluri printFun(1) și printFun(1) apeluri printFun(0) . printFun(0) merge la declarația if și revine la printFun(1) . Declarațiile rămase ale printFun(1) sunt executate și revine la printFun(2) și așa mai departe. În ieșire, valorile de la 3 la 1 sunt tipărite și apoi sunt tipărite de la 1 la 3. Stiva de memorie a fost prezentată în diagrama de mai jos.
 
 
 
  Recursie VS Iterație  
 
 
 
 
  SR nr.  
 
  Recursiune  
 
  Repetare  
 
 
 
1)
 
Se termină când cazul de bază devine adevărat.
 
Se termină când condiția devine falsă.
 
 
 
2)
 
Folosit cu funcții.
 
Folosit cu bucle.
 
 
 
3)
 
Fiecare apel recursiv are nevoie de spațiu suplimentar în memoria stivei.
 
Fiecare iterație nu necesită spațiu suplimentar.
 
 
 
4)
 
Mărimea codului mai mică.
 
Mărimea codului mai mare.
 
 
 
 
Acum, să discutăm câteva probleme practice care pot fi rezolvate prin utilizarea recursiunii și să înțelegem funcționarea ei de bază. Pentru înțelegerea de bază, vă rugăm să citiți următoarele articole. 
Înțelegerea de bază a recursiunii. 
  Problema 1: Scrieți un program și o relație de recurență pentru a găsi seria Fibonacci a lui n unde n>2 . 
  Ecuație matematică:  
 
n if n == 0, n == 1; fib(n) = fib(n-1) + fib(n-2) otherwise;>
 
  Relația de recurență:  
 
T(n) = T(n-1) + T(n-2) + O(1)>
 
  Program recursiv:  
 
 Input: n = 5 Output: Fibonacci series of 5 numbers is : 0 1 1 2 3>
 
  Implementare:  
 
C++
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // C++ code to implement Fibonacci series> #include> using> namespace> std;> > // Function for fibonacci> > int> fib(>int> n)> > > // Driver Code> int> main()> {> >// Initialize variable n.> >int> n = 5;> >cout<<>'Fibonacci series of 5 numbers is: '>;> > >// for loop to print the fibonacci series.> >for> (>int> i = 0; i   {   cout<' ';   }   return 0;  }>
 
 
 
 
    
 
>
 
    
 
>
 
 
C
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // C code to implement Fibonacci series> #include> > // Function for fibonacci> int> fib(>int> n)> > >// Stop condition> >if> (n == 0)> >return> 0;> > >// Stop condition> >if> (n == 1> > // Driver Code> int> main()> {> >// Initialize variable n.> >int> n = 5;> >printf>(>'Fibonacci series '> >'of %d numbers is: '>,> >n);> > >// for loop to print the fibonacci series.> >for> (>int> i = 0; i   printf('%d ', fib(i));   }   return 0;  }>
 
 
 
 
    
 
>
 
    
 
>
 
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // Java code to implement Fibonacci series> import> java.util.*;> > class> GFG> {> > // Function for fibonacci> static> int> fib(>int> n)> > > // Driver Code> public> static> void> main(String []args)> {> > >// Initialize variable n.> >int> n =>5>;> >System.out.print(>'Fibonacci series of 5 numbers is: '>);> > >// for loop to print the fibonacci series.> >for> (>int> i =>0>; i   {   System.out.print(fib(i)+' ');   }  }  }    // This code is contributed by rutvik_56.>
 
 
 
 
1 milion câte 0
    
 
>
 
    
 
>
 
 
Python3
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 # Python code to implement Fibonacci series> > # Function for fibonacci> def> fib(n):> > ># Stop condition> >if> (n>=>=> 0>):> >return> 0> > ># Stop condition> >if> (n>=>=> 1> or> n>=>=> 2>):> >return> 1> > ># Recursion function> >else>:> >return> (fib(n>-> 1>)>+> fib(n>-> 2>))> > > # Driver Code> > # Initialize variable n.> n>=> 5>;> print>(>'Fibonacci series of 5 numbers is :'>,end>=>' '>)> > # for loop to print the fibonacci series.> for> i>in> range>(>0>,n):> >print>(fib(i),end>=>' '>)> 
 
 
 
 
    
 
>
 
    
 
>
 
 
C#
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 using> System;> > public> class> GFG> {> > >// Function for fibonacci> >static> int> fib(>int> n)> > n == 2)> >return> 1;> > >// Recursion function> >else> >return> (fib(n - 1) + fib(n - 2));> >> > >// Driver Code> >static> public> void> Main ()> >{> > >// Initialize variable n.> >int> n = 5;> >Console.Write(>'Fibonacci series of 5 numbers is: '>);> > >// for loop to print the fibonacci series.> >for> (>int> i = 0; i   {   Console.Write(fib(i) + ' ');   }   }  }    // This code is contributed by avanitrachhadiya2155>
 
 
 
 
    
 
>
 
    
 
>
 
 
Javascript
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > // JavaScript code to implement Fibonacci series> > // Function for fibonacci> function> fib(n)>  n == 2)> >return> 1;> >// Recursion function> >else> >return> fib(n-1) + fib(n-2);> > > // Initialize variable n.> let n = 5;> > document.write(>'Fibonacci series of 5 numbers is: '>);> > // for loop to print the fibonacci series.> for>(let i = 0; i  {   document.write(fib(i) + ' ');  }>
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
Fibonacci series of 5 numbers is: 0 1 1 2 3>
 
  Complexitatea timpului: O(2n) 
  Spațiu auxiliar: Pe)
 
Iată arborele recursiv pentru intrarea 5, care arată o imagine clară a modului în care o problemă mare poate fi rezolvată în altele mai mici. 
fib(n) este o funcție Fibonacci. Complexitatea de timp a programului dat poate depinde de apelul funcției.
if else declarație în java
  
 
fib(n) -> nivel CBT (UB) -> 2^n-1 noduri -> 2^n apel de funcție -> 2^n*O(1) -> T(n) = O(2^n)
 
 
Pentru cel mai bun caz.
 
T(n) = ?(2^n2)>
 
  Lucru:  
 
 
 
  Problema 2: Scrieți un program și o relație de recurență pentru a găsi Factorialul lui n unde n>2 . 
  Ecuație matematică:  
 
1 if n == 0 or n == 1; f(n) = n*f(n-1) if n>1;>
 
  Relația de recurență:  
 
T(n) = 1 for n = 0 T(n) = 1 + T(n-1) for n>0>
 
  Program recursiv:   
  Intrare: n = 5 
  Ieșire:   
factorial de 5 este: 120 
  Implementare:  
 
C++
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // C++ code to implement factorial> #include> using> namespace> std;> > // Factorial function> int> f(>int> n)>  n == 1)> >return> 1;> > >// Recursive condition> >else> >return> n * f(n - 1);> > > // Driver code> int> main()> {> >int> n = 5;> >cout<<>'factorial of '><' is: '<  return 0;  }>
 
 
 
 
    
 
>
 
    
 
>
 
 
C
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // C code to implement factorial> #include> > // Factorial function> int> f(>int> n)> > >// Stop condition> >if> (n == 0> > // Driver code> int> main()> {> >int> n = 5;> >printf>(>'factorial of %d is: %d'>, n, f(n));> >return> 0;> }> 
 
 
 
 
    
 
>
 
    
 
>
 
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // Java code to implement factorial> public> class> GFG> {> > >// Factorial function> >static> int> f(>int> n)> >> > >// Driver code> >public> static> void> main(String[] args)> >{> >int> n =>5>;> >System.out.println(>'factorial of '> + n +>' is: '> + f(n));> >}> }> > // This code is contributed by divyesh072019.> 
 
 
 
 
    
 
>
 
    
 
>
 
 
Python3
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 # Python3 code to implement factorial> > # Factorial function> def> f(n):> > ># Stop condition> >if> (n>=>=> 0> or> n>=>=> 1>):> >return> 1>;> > ># Recursive condition> >else>:> >return> n>*> f(n>-> 1>);> > > # Driver code> if> __name__>=>=>'__main__'>:> > >n>=> 5>;> >print>(>'factorial of'>,n,>'is:'>,f(n))> > ># This code is contributed by pratham76.> 
 
 
 
 
    
 
>
 
    
 
>
 
 
C#
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 // C# code to implement factorial> using> System;> class> GFG {> > >// Factorial function> >static> int> f(>int> n)> > n == 1)> >return> 1;> > >// Recursive condition> >else> >return> n * f(n - 1);> >> > >// Driver code> >static> void> Main()> >{> >int> n = 5;> >Console.WriteLine(>'factorial of '> + n +>' is: '> + f(n));> >}> }> > // This code is contributed by divyeshrabadiya07.> 
 
 
 
 
    
 
>
 
    
 
>
 
 
Javascript
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 > // JavaScript code to implement factorial> > // Factorial function> function> f(n)>  n == 1)> >return> 1;> > >// Recursive condition> >else> >return> n*f(n-1);> > > // Initialize variable n.> let n = 5;> document.write(>'factorial of '>+ n +>' is: '> + f(n));> > // This code is contributed by probinsah.> > 
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
factorial of 5 is: 120>
 
  Complexitatea timpului: Pe) 
  Spațiu auxiliar: Pe)
 
  Lucru:   
 
  
Diagrama funcției de recursivitate factorială pentru intrarea utilizatorului 5.
 
Exemplu: Aplicații reale ale recursiunii în probleme reale
 
Recursiunea este o tehnică puternică care are multe aplicații în informatică și programare. Iată câteva dintre aplicațiile comune ale recursiunii:
 
Parcurgerea arborilor și a graficelor: recursiunea este frecvent utilizată pentru parcurgerea și căutarea structurilor de date, cum ar fi arbori și grafice. Algoritmii recursivi pot fi utilizați pentru a explora toate nodurile sau vârfurile unui arbore sau grafic într-un mod sistematic. Algoritmi de sortare: algoritmii recursivi sunt utilizați și în algoritmii de sortare, cum ar fi sortarea rapidă și sortarea prin îmbinare. Acești algoritmi folosesc recursiunea pentru a împărți datele în subgrupuri sau subliste mai mici, pentru a le sorta și apoi a le îmbina din nou. Algoritmi de împărțire și cucerire: mulți algoritmi care folosesc o abordare de împărțire și cucerire, cum ar fi algoritmul de căutare binar, folosesc recursiunea pentru a descompune problema în subprobleme mai mici. Generarea fractale: Formele și modelele fractale pot fi generate folosind algoritmi recursivi. De exemplu, mulțimea Mandelbrot este generată prin aplicarea în mod repetat a unei formule recursive numerelor complexe. Algoritmi de backtracking : algoritmii de backtracking sunt utilizați pentru a rezolva probleme care implică luarea unei secvențe de decizii, unde fiecare decizie depinde de cele anterioare. Acești algoritmi pot fi implementați folosind recursiunea pentru a explora toate căile posibile și pentru a reveni atunci când nu este găsită o soluție. Memorare: Memorarea este o tehnică care implică stocarea rezultatelor apelurilor de funcții costisitoare și returnarea rezultatului stocat în cache atunci când apar din nou aceleași intrări. Memorizarea poate fi implementată folosind funcții recursive pentru a calcula și stoca în cache rezultatele subproblemelor.
 
Acestea sunt doar câteva exemple din numeroasele aplicații ale recursiunii în informatică și programare. Recursiunea este un instrument versatil și puternic care poate fi folosit pentru a rezolva multe tipuri diferite de probleme.
 
Explicație: un exemplu real de recursivitate:
 
Recursiunea este o tehnică de programare care implică o funcție care se autoapelează. Poate fi un instrument puternic pentru rezolvarea problemelor complexe, dar necesită și o implementare atentă pentru a evita bucle infinite și depășiri de stive.
 
Iată un exemplu de implementare a recursiunii în Python:
 
C++
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 #include> using> namespace> std;> int> factorial(>int> n)> {> > >// Base case: if n is 0 or 1, return 1> >if> (n == 0 || n == 1) {> >return> 1;> >}> > >// Recursive case: if n is greater than 1,> >// call the function with n-1 and multiply by n> >else> {> >return> n * factorial(n - 1);> >}> }> > int> main()> {> > >// Call the factorial function and print the result> >int> result = factorial(5);> >cout << result 
 
 
 
 
    
 
>
 
    
 
>
 
 
Java
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 import> java.util.*;> > class> Main {> >public> static> int> factorial(>int> n)> >{> >// Base case: if n is 0 or 1, return 1> >if> (n ==>0> || n ==>1>) {> >return> 1>;> >}> > >// Recursive case: if n is greater than 1,> >// call the function with n-1 and multiply by n> >else> {> >return> n * factorial(n ->1>);> >}> >}> > >public> static> void> main(String[] args)> >{> >// Call the factorial function and print the result> >int> result = factorial(>5>);> >System.out.println(result);>// Output: 120> >}> }> 
 
 
 
 
    
 
>
 
    
 
>
 
 
Python3
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 def> factorial(n):> ># Base case: if n is 0 or 1, return 1> >if> n>=>=> 0> or> n>=>=> 1>:> >return> 1> > ># Recursive case: if n is greater than 1, call the function with n-1 and multiply by n> >else>:> >return> n>*> factorial(n>->1>)> > # Call the factorial function and print the result> result>=> factorial(>5>)> print>(result)># Output: 120> 
 
 
 
 
    
 
>
 
    
 
>
 
 
C#
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 using> System;> > class> MainClass {> >public> static> int> factorial(>int> n)> >{> >// Base case: if n is 0 or 1, return 1> >if> (n == 0 || n == 1) {> >return> 1;> >}> > >// Recursive case: if n is greater than 1,> >// call the function with n-1 and multiply by n> >else> {> >return> n * factorial(n - 1);> >}> >}> > >public> static> void> Main (>string>[] args) {> >// Call the factorial function and print the result> >int> result = factorial(5);> >Console.WriteLine(result);>// Output: 120> >}> }> 
 
 
 
 
    
 
>
 
comanda linux pentru zip
    
 
>
 
 
Javascript
    
 
     
  
 
    
 
     
     
    
 
 
 
 
 
 function> factorial(n) {> >// Base case: if n is 0 or 1, return 1> >if> (n === 0 || n === 1) {> >return> 1;> >}> > >// Recursive case: if n is greater than 1, call the function with n-1 and multiply by n> >else> {> >return> n * factorial(n - 1);> >}> }> > // Call the factorial function and print the result> const result = factorial(5);> console.log(result);>// Output: 120> 
 
 
 
 
    
 
>
 
    
 
>
 
  Ieșire  
 
120>
 
În acest exemplu, definim o funcție numită factorial care ia un număr întreg n ca intrare. Funcția folosește recursiunea pentru a calcula factorialul lui n (adică produsul tuturor numerelor întregi pozitive până la n).
 
Funcția factorială verifică mai întâi dacă n este 0 sau 1, care sunt cazurile de bază. Dacă n este 0 sau 1, funcția returnează 1, deoarece 0! si 1! sunt amandoi 1.
 
Dacă n este mai mare decât 1, funcția intră în cazul recursiv. Se numește cu n-1 drept argument și înmulțește rezultatul cu n. Aceasta calculează n! prin calculul recursiv (n-1)!.
 
Este important de reținut că recursiunea poate fi ineficientă și poate duce la depășiri de stive dacă nu este utilizată cu atenție. Fiecare apel de funcție adaugă un nou cadru la stiva de apeluri, ceea ce poate face ca stiva să devină prea mare dacă recursiunea este prea profundă. În plus, recursiunea poate face codul mai dificil de înțeles și de depanat, deoarece necesită să ne gândim la mai multe niveluri de apeluri de funcții.
 
Cu toate acestea, recursiunea poate fi, de asemenea, un instrument puternic pentru rezolvarea problemelor complexe, în special a celor care implică descompunerea unei probleme în subprobleme mai mici. Când este utilizată corect, recursiunea poate face codul mai elegant și mai ușor de citit.
 
  Care sunt dezavantajele programării recursive față de programarea iterativă?   
Rețineți că atât programele recursive, cât și cele iterative au aceleași puteri de rezolvare a problemelor, adică fiecare program recursiv poate fi scris iterativ și viceversa este, de asemenea, adevărat. Programul recursiv are cerințe de spațiu mai mari decât programul iterativ, deoarece toate funcțiile vor rămâne în stivă până când se ajunge la cazul de bază. Are, de asemenea, cerințe de timp mai mari din cauza apelurilor de funcții și a returnărilor.
 
Mai mult decât atât, din cauza lungimii mai mici a codului, codurile sunt greu de înțeles și, prin urmare, trebuie să aveți grijă suplimentară în timpul scrierii codului. Computerul poate rămâne fără memorie dacă apelurile recursive nu sunt verificate corect.
 
  Care sunt avantajele programării recursive față de programarea iterativă?   
Recursiunea oferă o modalitate curată și simplă de a scrie cod. Unele probleme sunt în mod inerent recursive, cum ar fi traversările arborilor, Turnul din Hanoi , etc. Pentru astfel de probleme, este de preferat să scrieți cod recursiv. Putem scrie astfel de coduri și în mod iterativ cu ajutorul unei structuri de date stive. De exemplu, consultați Inorder Tree Traversal fără recurs, Turnul iterativ din Hanoi.
 
  Rezumatul recursiunii:  
 
 
Există două tipuri de cazuri în recursivitate, adică cazul recursiv și un caz de bază.
 
Cazul de bază este folosit pentru a termina funcția recursivă atunci când cazul se dovedește a fi adevărat.
 
Fiecare apel recursiv face o nouă copie a acelei metode în memoria stivei.
 
Recursiunea infinită poate duce la epuizarea memoriei stivei.
 
Exemple de algoritmi recursivi: Sortare prin îmbinare, Sortare rapidă, Turnul din Hanoi, Seria Fibonacci, Problemă factorială etc.
 
 
  Probleme de practică bazate pe rezultate pentru începători:   
Întrebări practice pentru recursivitate | Setul 1 
Întrebări practice pentru recursivitate | Setul 2 
Întrebări practice pentru recursivitate | Setul 3 
Întrebări practice pentru recursivitate | Setul 4 
Întrebări practice pentru recursivitate | Setul 5 
Întrebări practice pentru recursivitate | Setul 6 
Întrebări practice pentru recursivitate | Setul 7 
   Test despre recursivitate    
   Practică de codificare asupra recursiunii:    
   Toate articolele despre recursivitate    
Probleme de practică recursive cu soluții