Què és la recursivitat?
El procés en què una funció s'anomena directament o indirectament s'anomena recursivitat i la funció corresponent s'anomena funció recursiva. Mitjançant un algorisme recursiu, certs problemes es poden resoldre amb força facilitat. Exemples d'aquests problemes són Torres de Hanoi (TOH) , Inorder/Preorder/Postorder Tree Traversals , DFS de Graph , etc. Una funció recursiva resol un problema particular cridant una còpia de si mateixa i resolent subproblemes més petits dels problemes originals. Es poden generar moltes més trucades recursives quan sigui necessari. És essencial saber que hem de proporcionar un cas determinat per tal de finalitzar aquest procés de recursivitat. Així que podem dir que cada vegada que la funció es crida a si mateixa amb una versió més senzilla del problema original.
Necessitat de recurrència
La recursió és una tècnica sorprenent amb l'ajuda de la qual podem reduir la longitud del nostre codi i facilitar la lectura i l'escriptura. Té certs avantatges respecte a la tècnica d'iteració que es comentarà més endavant. Una tasca que es pot definir amb la seva subtasca similar, la recursivitat és una de les millors solucions per a això. Per exemple; El factorial d'un nombre.
Propietats de la recurrència:
- Realitzar les mateixes operacions diverses vegades amb diferents entrades.
- En cada pas, intentem entrades més petites per reduir el problema.
- La condició base és necessària per aturar la recursivitat, en cas contrari es produirà un bucle infinit.
Algorisme: passos
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.>
Una interpretació matemàtica
Considerem un problema que té un programador per determinar la suma dels primers n nombres naturals, hi ha diverses maneres de fer-ho, però l'enfocament més senzill és simplement sumar els nombres que comencen de 1 a n. Així que la funció simplement sembla així,
enfocament(1) – Simplement afegint un per un
f(n) = 1 + 2 + 3 +……..+ n
però hi ha un altre enfocament matemàtic per representar això,
enfocament(2) – Suma recursiva
f(n) = 1 n=1
f(n) = n + f(n-1) n>1
Hi ha una diferència senzilla entre l'enfocament (1) i l'enfocament (2) i això està en enfocament (2) la funció f( ) El mateix s'anomena dins de la funció, de manera que aquest fenomen s'anomena recursivitat, i la funció que conté recursivitat s'anomena funció recursiva, al final, aquesta és una gran eina a la mà dels programadors per codificar alguns problemes de manera molt més fàcil i eficient. manera.
Com s'emmagatzemen les funcions recursives a la memòria?
La recursivitat utilitza més memòria, perquè la funció recursiva s'afegeix a la pila amb cada trucada recursiva i hi manté els valors fins que s'acaba la crida. La funció recursiva utilitza l'estructura LIFO (ÚLTIM EN ENTRADA, PRIMERA OUT) igual que l'estructura de dades de la pila. pila-estructura de dades/
Quina és la condició base en recursivitat?
En el programa recursiu, es proporciona la solució al cas base i la solució al problema més gran s'expressa en termes de problemes més petits.
int fact(int n) { if (n <= 1) // base case return 1; else return n*fact(n-1); }> A l'exemple anterior, es defineix el cas base per a n <= 1 i el valor més gran d'un nombre es pot resoldre convertint-ne un de més petit fins que s'arribi al cas base.
Com es resol un problema en particular mitjançant la recursivitat?
La idea és representar un problema en termes d'un o més problemes més petits, i afegir una o més condicions base que aturin la recursivitat. Per exemple, calculem el factorial n si coneixem el factorial de (n-1). El cas base per al factorial seria n = 0. Tornem 1 quan n = 0.
Per què es produeix un error de desbordament de pila en recursivitat?
Si no s'arriba al cas base o no es defineix, pot sorgir el problema de desbordament de la pila. Prenguem un exemple per entendre-ho.
int fact(int n) { // wrong base case (it may cause // stack overflow). if (n == 100) return 1; else return n*fact(n-1); }> Si s'anomena fet(10), cridarà fet(9), fet(8), fet(7), i així successivament, però el nombre mai arribarà a 100. Per tant, no s'arriba al cas base. Si la memòria s'esgota per aquestes funcions de la pila, provocarà un error de desbordament de la pila.
Quina diferència hi ha entre recursivitat directa i indirecta?
Una funció fun s'anomena recursiva directa si anomena la mateixa funció fun. Una funció fun s'anomena recursiva indirecta si crida a una altra funció, per exemple, fun_new i fun_new crida directament o indirectament a la diversió. La diferència entre recursivitat directa i indirecta s'ha il·lustrat a la taula 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... }> Quina diferència hi ha entre la recursió amb cua i la sense cua?
Una funció recursiva és recursiva de cua quan una crida recursiva és l'última cosa que executa la funció. Si us plau, consulteu article de recursivitat de la cua per als detalls.
Com s'assigna la memòria a diferents trucades de funcions en recursivitat?
Quan s'anomena qualsevol funció des de main(), la memòria s'hi assigna a la pila. Una funció recursiva s'anomena a si mateixa, la memòria d'una funció cridada s'assigna a sobre de la memòria assignada a la funció de crida i es crea una còpia diferent de les variables locals per a cada trucada de funció. Quan s'arriba al cas base, la funció retorna el seu valor a la funció per qui la crida i es desassigna la memòria i el procés continua.
Prenguem l'exemple de com funciona la recursió prenent una funció simple.
CPP
// A C++ program to demonstrate working of> // recursion> #include> using> namespace> std;> > void> printFun(>int> test)> {> >if> (test <1)> >return>;> >else> {> >cout << test <<>' '>;> >printFun(test - 1);>// statement 2> >cout << test <<>' '>;> >return>;> >}> }> > // Driver Code> int> main()> {> >int> test = 3;> >printFun(test);> }> |
>
>
Java
10 de 50
// A Java program to demonstrate working of> // recursion> class> GFG {> >static> void> printFun(>int> test)> >{> >if> (test <>1>)> >return>;> >else> {> >System.out.printf(>'%d '>, test);> >printFun(test ->1>);>// statement 2> >System.out.printf(>'%d '>, test);> >return>;> >}> >}> > >// Driver Code> >public> static> void> main(String[] args)> >{> >int> test =>3>;> >printFun(test);> >}> }> > // This code is contributed by> // Smitha Dinesh Semwal> |
>
>
Python 3
# A Python 3 program to> # demonstrate working of> # recursion> > > def> printFun(test):> > >if> (test <>1>):> >return> >else>:> > >print>(test, end>=>' '>)> >printFun(test>->1>)># statement 2> >print>(test, end>=>' '>)> >return> > # Driver Code> test>=> 3> printFun(test)> > # This code is contributed by> # Smitha Dinesh Semwal> |
>
>
C#
// A C# program to demonstrate> // working of recursion> using> System;> > class> GFG {> > >// function to demonstrate> >// working of recursion> >static> void> printFun(>int> test)> >{> >if> (test <1)> >return>;> >else> {> >Console.Write(test +>' '>);> > >// statement 2> >printFun(test - 1);> > >Console.Write(test +>' '>);> >return>;> >}> >}> > >// Driver Code> >public> static> void> Main(String[] args)> >{> >int> test = 3;> >printFun(test);> >}> }> > // This code is contributed by Anshul Aggarwal.> |
>
>
PHP
// PHP program to demonstrate // working of recursion // function to demonstrate // working of recursion function printFun($test) { if ($test <1) return; else { echo('$test '); // statement 2 printFun($test-1); echo('$test '); return; } } // Driver Code $test = 3; printFun($test); // This code is contributed by // Smitha Dinesh Semwal. ?>> |
>
>
Javascript
> > // 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);> > > |
>
>Sortida
3 2 1 1 2 3>
Complexitat temporal: O(1)
Espai auxiliar: O(1)
Quan printFun(3) s'anomena des de main(), s'assigna la memòria printFun(3) i una prova de variable local s'inicia a 3 i la instrucció 1 a 4 s'empeny a la pila tal com es mostra al diagrama següent. Primer imprimeix '3'. A la declaració 2, printFun(2) es crida i s'assigna la memòria printFun(2) i una prova de variable local s'inicia a 2 i la instrucció 1 a 4 s'empenya a la pila. De la mateixa manera, printFun(2) trucades printFun(1) i printFun(1) trucades printFun(0) . printFun(0) va a la declaració if i torna a printFun(1) . La resta de declaracions de printFun(1) s'executen i es torna a printFun(2) etcètera. A la sortida, s'imprimeixen els valors de 3 a 1 i després s'imprimeixen de l'1 al 3. La pila de memòria s'ha mostrat al diagrama següent.
Recursió VS iteració
| SR No. | Recursió | Iteració |
| 1) | Acaba quan el cas base esdevé cert. | S'acaba quan la condició esdevé falsa. |
| 2) | S'utilitza amb funcions. | S'utilitza amb bucles. |
| 3) | Cada trucada recursiva necessita espai addicional a la memòria de pila. | Cada iteració no requereix espai addicional. |
| 4) | Mida de codi més petita. | Mida de codi més gran. |
Ara, analitzem alguns problemes pràctics que es poden resoldre mitjançant l'ús de la recursivitat i entenem el seu funcionament bàsic. Per a una comprensió bàsica, llegiu els articles següents.
Coneixement bàsic de la recursència.
Problema 1: Escriu un programa i una relació de recurrència per trobar la sèrie de Fibonacci de n on n>2 .
Equació matemàtica:
n if n == 0, n == 1; fib(n) = fib(n-1) + fib(n-2) otherwise;>
Relació de recurrència:
T(n) = T(n-1) + T(n-2) + O(1)>
Programa recursiu:
Input: n = 5 Output: Fibonacci series of 5 numbers is : 0 1 1 2 3>
Implementació:
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.> |
>
>
Python 3
# 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#
edat de sara ali khan
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) + ' '); } > |
>
>Sortida
Fibonacci series of 5 numbers is: 0 1 1 2 3>
Complexitat temporal: O(2n)
Espai auxiliar: O(n)
Aquí teniu l'arbre recursiu de l'entrada 5 que mostra una imatge clara de com es pot resoldre un gran problema en altres més petits.
fib(n) és una funció de Fibonacci. La complexitat temporal del programa donat pot dependre de la trucada de funció.
fib(n) -> nivell CBT (UB) -> 2^n-1 nodes -> 2^n crida de funció -> 2^n*O(1) -> T(n) = O(2^n)
Per al millor cas.
T(n) = ?(2^n2)>
Treball:
Problema 2: Escriu un programa i una relació de recurrència per trobar el factorial de n on n>2 .
Equació matemàtica:
1 if n == 0 or n == 1; f(n) = n*f(n-1) if n>1;>
Relació de recurrència:
T(n) = 1 for n = 0 T(n) = 1 + T(n-1) for n>0>
Programa recursiu:
Entrada: n = 5
Sortida:
el factorial de 5 és: 120
Implementació:
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
cadena comparable en 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.> |
>
>
Python 3
# 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.> > |
>
>Sortida
factorial of 5 is: 120>
Complexitat temporal: O(n)
Espai auxiliar: O(n)
Treball:
Diagrama de la funció de recursivitat factorial per a l'entrada de l'usuari 5.
Exemple: Aplicacions reals de la recursivitat en problemes reals
La recursió és una tècnica potent que té moltes aplicacions en informàtica i programació. Aquestes són algunes de les aplicacions habituals de la recursivitat:
- Travessa d'arbres i gràfics: la recursència s'utilitza sovint per recórrer i cercar estructures de dades com ara arbres i gràfics. Els algorismes recursius es poden utilitzar per explorar tots els nodes o vèrtexs d'un arbre o gràfic de manera sistemàtica. Algorismes d'ordenació: els algorismes recursius també s'utilitzen en algorismes d'ordenació com ara quicksort i merge sort. Aquests algorismes utilitzen la recursivitat per dividir les dades en subquadrícules o subllistes més petites, ordenar-les i tornar-les a combinar. Algorismes de divideix i venços: molts algorismes que utilitzen un enfocament de divideix i venços, com l'algoritme de cerca binària, utilitzen la recursivitat per dividir el problema en subproblemes més petits. Generació de fractals: es poden generar formes i patrons fractals mitjançant algorismes recursius. Per exemple, el conjunt de Mandelbrot es genera aplicant repetidament una fórmula recursiva a nombres complexos. Algorismes de retrocés : Els algorismes de retrocés s'utilitzen per resoldre problemes que impliquen prendre una seqüència de decisions, on cada decisió depèn de les anteriors. Aquests algorismes es poden implementar mitjançant la recursivitat per explorar tots els camins possibles i fer marxa enrere quan no es troba una solució. Memoization: la memoització és una tècnica que consisteix a emmagatzemar els resultats de trucades de funcions cares i retornar el resultat de la memòria cau quan es tornen a produir les mateixes entrades. La memorització es pot implementar mitjançant funcions recursives per calcular i emmagatzemar a la memòria cau els resultats dels subproblemes.
Aquests són només alguns exemples de les moltes aplicacions de la recursivitat en informàtica i programació. La recursió és una eina versàtil i potent que es pot utilitzar per resoldre molts tipus diferents de problemes.
Explicació: un exemple real de recursivitat:
La recursivitat és una tècnica de programació que implica una funció que es crida a si mateixa. Pot ser una eina poderosa per resoldre problemes complexos, però també requereix una implementació acurada per evitar bucles infinits i desbordaments de pila.
Aquí teniu un exemple d'implementació de la recursivitat a 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> >}> }> |
>
>
Python 3
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> >}> }> |
>
>
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> |
>
>Sortida
120>
En aquest exemple, definim una funció anomenada factorial que pren un nombre enter n com a entrada. La funció utilitza la recursivitat per calcular el factorial de n (és a dir, el producte de tots els nombres enters positius fins a n).
La funció factorial comprova primer si n és 0 o 1, que són els casos bàsics. Si n és 0 o 1, la funció retorna 1, ja que 0! i 1! tots dos són 1.
ipconfig lliure de linux
Si n és més gran que 1, la funció entra al cas recursiu. S'anomena amb n-1 com a argument i multiplica el resultat per n. Això calcula n! calculant recursivament (n-1)!.
És important tenir en compte que la recursivitat pot ser ineficient i provocar desbordaments de pila si no s'utilitza amb cura. Cada trucada de funció afegeix un nou marc a la pila de trucades, que pot fer que la pila creixi massa gran si la recursivitat és massa profunda. A més, la recursivitat pot fer que el codi sigui més difícil d'entendre i depurar, ja que requereix pensar en diversos nivells de trucades de funcions.
Tanmateix, la recursivitat també pot ser una eina poderosa per resoldre problemes complexos, especialment aquells que impliquen dividir un problema en subproblemes més petits. Quan s'utilitza correctament, la recursivitat pot fer que el codi sigui més elegant i més fàcil de llegir.
Quins són els desavantatges de la programació recursiva sobre la programació iterativa?
Tingueu en compte que tant els programes recursius com els iteratius tenen els mateixos poders de resolució de problemes, és a dir, cada programa recursiu es pot escriure iterativament i viceversa també és cert. El programa recursiu té més requisits d'espai que el programa iteratiu, ja que totes les funcions romandran a la pila fins que s'arribi al cas base. També té més requisits de temps a causa de les trucades de funcions i els retorns generals.
A més, a causa de la menor longitud del codi, els codis són difícils d'entendre i, per tant, s'ha de tenir molta cura en escriure el codi. L'ordinador pot quedar-se sense memòria si les trucades recursives no es comproven correctament.
Quins són els avantatges de la programació recursiva sobre la programació iterativa?
La recursivitat proporciona una manera neta i senzilla d'escriure codi. Alguns problemes són inherentment recursius com els recorreguts d'arbres, Torre de Hanoi , etc. Per a aquests problemes, és preferible escriure codi recursiu. També podem escriure aquests codis de manera iterativa amb l'ajuda d'una estructura de dades de pila. Per exemple, consulteu Inorder Tree Traversal without Recursion, Torre iterativa de Hanoi.
Resum de la recurrència:
- Hi ha dos tipus de casos en recursivitat, és a dir, el cas recursiu i el cas base.
- El cas base s'utilitza per acabar la funció recursiva quan el cas resulta ser cert.
- Cada trucada recursiva fa una nova còpia d'aquest mètode a la memòria de pila.
- La recursivitat infinita pot provocar que es quedi sense memòria de pila.
- Exemples d'algorismes recursius: Ordenació combinada, Ordenació ràpida, Torre de Hanoi, Sèrie de Fibonacci, Problema factorial, etc.
Problemes de pràctica basats en resultats per a principiants:
Preguntes pràctiques per a la recursivitat | Set 1
Preguntes pràctiques per a la recursivitat | Set 2
Preguntes pràctiques per a la recursivitat | Set 3
Preguntes pràctiques per a la recursivitat | Set 4
Preguntes pràctiques per a la recursivitat | Set 5
Preguntes pràctiques per a la recursivitat | Set 6
Preguntes pràctiques per a la recursivitat | Set 7
Test sobre recursivitat
Pràctica de codificació sobre recursivitat:
Tots els articles sobre recursivitat
Problemes de pràctica recursiva amb solucions