Vad är rekursion?
Processen där en funktion anropar sig själv direkt eller indirekt kallas rekursion och motsvarande funktion kallas rekursiv funktion. Med hjälp av en rekursiv algoritm kan vissa problem lösas ganska enkelt. Exempel på sådana problem är Towers of Hanoi (TOH) , Inorder/Preorder/Postorder Tree Traversals , DFS of Graph, etc. En rekursiv funktion löser ett visst problem genom att anropa en kopia av sig själv och lösa mindre delproblem av originalproblemen. Många fler rekursiva samtal kan genereras när och när det behövs. Det är viktigt att veta att vi bör tillhandahålla ett visst fall för att avsluta denna rekursionsprocess. Så vi kan säga att varje gång funktionen anropar sig själv med en enklare version av det ursprungliga problemet.
Behov av rekursion
Rekursion är en fantastisk teknik med hjälp av vilken vi kan minska längden på vår kod och göra det lättare att läsa och skriva. Det har vissa fördelar jämfört med iterationstekniken som kommer att diskuteras senare. En uppgift som kan definieras med sin liknande deluppgift, rekursion är en av de bästa lösningarna för den. Till exempel; Faktorn för ett nummer.
Egenskaper för rekursion:
- Utför samma operationer flera gånger med olika ingångar.
- I varje steg försöker vi mindre ingångar för att göra problemet mindre.
- Basvillkor behövs för att stoppa rekursionen, annars kommer oändlig loop att inträffa.
Algoritm: Steg
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.>
En matematisk tolkning
Låt oss överväga ett problem som en programmerare har för att bestämma summan av de första n naturliga talen, det finns flera sätt att göra det på, men det enklaste sättet är helt enkelt att lägga till talen från 1 till n. Så funktionen ser helt enkelt ut så här,
approach(1) – Lägg helt enkelt till en efter en
f(n) = 1 + 2 + 3 +……..+ n
men det finns en annan matematisk metod för att representera detta,
approach(2) – Rekursiv addering
f(n) = 1 n=1
f(n) = n + f(n-1) n>1
Det finns en enkel skillnad mellan tillvägagångssätt (1) och tillvägagångssätt (2) och det är i tillvägagångssätt(2) funktionen f( ) självt kallas inuti funktionen, så detta fenomen heter rekursion, och funktionen som innehåller rekursion kallas rekursiv funktion, i slutet är detta ett bra verktyg i programmerarnas hand för att koda vissa problem på mycket enklare och effektivare sätt.
Hur lagras rekursiva funktioner i minnet?
Rekursion använder mer minne, eftersom den rekursiva funktionen lägger till stacken med varje rekursivt anrop och behåller värdena där tills anropet är klart. Den rekursiva funktionen använder strukturen LIFO (LAST IN FIRST OUT) precis som stackdatastrukturen. stack-data-structure/
Vad är bastillståndet vid rekursion?
I det rekursiva programmet ges lösningen på basfallet och lösningen på det större problemet uttrycks i termer av mindre problem.
int fact(int n) { if (n <= 1) // base case return 1; else return n*fact(n-1); }> I exemplet ovan definieras basfallet för n <= 1 och det större värdet av ett tal kan lösas genom att konvertera till ett mindre tills basfallet uppnås.
Hur löses ett visst problem med hjälp av rekursion?
Tanken är att representera ett problem i form av ett eller flera mindre problem, och lägga till ett eller flera basvillkor som stoppar rekursionen. Till exempel, vi beräknar faktorial n om vi känner till faktorial för (n-1). Basfallet för faktoriell skulle vara n = 0. Vi returnerar 1 när n = 0.
Varför uppstår Stack Overflow-fel vid rekursion?
Om basfallet inte uppnås eller inte definieras, kan problemet med stackspill uppstå. Låt oss ta ett exempel för att förstå detta.
int fact(int n) { // wrong base case (it may cause // stack overflow). if (n == 100) return 1; else return n*fact(n-1); }> Om fakta(10) anropas kommer det att anropa fakta(9), fakta(8), fakta(7) och så vidare men talet kommer aldrig att nå 100. Så basfallet nås inte. Om minnet tar slut av dessa funktioner i stacken kommer det att orsaka ett stackspillfel.
Vad är skillnaden mellan direkt och indirekt rekursion?
En funktion fun kallas direkt rekursiv om den kallar samma funktion fun. En funktion fun kallas indirekt rekursiv om den anropar en annan funktion säg fun_new och fun_new anropar roligt direkt eller indirekt. Skillnaden mellan direkt och indirekt rekursion har illustrerats i tabell 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... }> Vad är skillnaden mellan tailed och non-tailed rekursion?
En rekursiv funktion är svansrekursiv när ett rekursivt anrop är det sista som exekveras av funktionen. Var god hänvisa svansrekursionsartikel för detaljer.
Hur tilldelas minne till olika funktionsanrop vid rekursion?
När någon funktion anropas från main(), allokeras minnet till den i stacken. En rekursiv funktion anropar sig själv, minnet för en anropad funktion allokeras ovanpå minnet som är allokerat till den anropande funktionen och en annan kopia av lokala variabler skapas för varje funktionsanrop. När basfallet uppnås returnerar funktionen sitt värde till den funktion som den anropas av och minnet avallokeras och processen fortsätter.
Låt oss ta exemplet på hur rekursion fungerar genom att ta en enkel funktion.
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
konvertera char till int java
// 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> |
>
>
Python3
# 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);> > > |
hur man konverterar str till int
>
>Produktion
3 2 1 1 2 3>
Tidskomplexitet: O(1)
Hjälputrymme: O(1)
När printFun(3) anropas från main(), minne allokeras till printFun(3) och ett lokalt variabeltest initieras till 3 och sats 1 till 4 skjuts på stacken som visas i diagrammet nedan. Den skriver först ut '3'. I uttalande 2, printFun(2) anropas och minne allokeras till printFun(2) och ett lokalt variabeltest initieras till 2 och sats 1 till 4 skjuts in i stacken. Liknande, printFun(2) samtal printFun(1) och printFun(1) samtal printFun(0) . printFun(0) går till om uttalande och det återgår till printFun(1) . De återstående uttalandena av printFun(1) exekveras och den återgår till printFun(2) och så vidare. I utgången skrivs värden från 3 till 1 ut och sedan 1 till 3 skrivs ut. Minnesstacken har visats i diagrammet nedan.
Rekursion VS Iteration
| SR nr. | Rekursion | Iteration |
| 1) | Avslutas när basfallet blir sant. | Upphör när villkoret blir falskt. |
| 2) | Används med funktioner. | Används med öglor. |
| 3) | Varje rekursivt samtal behöver extra utrymme i stackminnet. | Varje iteration kräver inget extra utrymme. |
| 4) | Mindre kodstorlek. | Större kodstorlek. |
Låt oss nu diskutera några praktiska problem som kan lösas genom att använda rekursion och förstå dess grundläggande funktion. För grundläggande förståelse läs följande artiklar.
Grundläggande förståelse för rekursion.
Problem 1: Skriv ett program och ett återkommande förhållande för att hitta Fibonacci-serien av n där n>2 .
Matematisk ekvation:
n if n == 0, n == 1; fib(n) = fib(n-1) + fib(n-2) otherwise;>
Återkommande relation:
T(n) = T(n-1) + T(n-2) + O(1)>
Rekursivt program:
Input: n = 5 Output: Fibonacci series of 5 numbers is : 0 1 1 2 3>
Genomförande:
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.> |
>
>
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) + ' '); }> |
>
>Produktion
Fibonacci series of 5 numbers is: 0 1 1 2 3>
Tidskomplexitet: O(2n)
Hjälputrymme: På)
Här är det rekursiva trädet för ingång 5 som visar en tydlig bild av hur ett stort problem kan lösas till mindre.
fib(n) är en Fibonacci-funktion. Tidskomplexiteten för det givna programmet kan bero på funktionsanropet.
fib(n) -> nivå CBT (UB) -> 2^n-1 noder -> 2^n funktionsanrop -> 2^n*O(1) -> T(n) = O(2^n)
För bästa fall.
T(n) = ?(2^n2)>
Arbetssätt:
Problem 2: Skriv ett program och en återkommande relation för att hitta faktorn för n där n>2 .
Matematisk ekvation:
1 if n == 0 or n == 1; f(n) = n*f(n-1) if n>1;>
Återkommande relation:
T(n) = 1 for n = 0 T(n) = 1 + T(n-1) for n>0>
Rekursivt program:
Inmatning: n = 5
Produktion:
faktor 5 är: 120
Genomförande:
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.> |
>
aes vs des
>
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.> > |
>
>Produktion
factorial of 5 is: 120>
Tidskomplexitet: På)
Hjälputrymme: På)
Arbetssätt:
Diagram över faktoriell rekursionsfunktion för användarinmatning 5.
Exempel: Verkliga tillämpningar av rekursion i verkliga problem
Rekursion är en kraftfull teknik som har många tillämpningar inom datavetenskap och programmering. Här är några av de vanligaste tillämpningarna av rekursion:
- Traversering av träd och grafer: Rekursion används ofta för att korsa och söka datastrukturer som träd och grafer. Rekursiva algoritmer kan användas för att utforska alla noder eller hörn i ett träd eller en graf på ett systematiskt sätt. Sorteringsalgoritmer: Rekursiva algoritmer används också i sorteringsalgoritmer som snabbsortering och sammanslagningssortering. Dessa algoritmer använder rekursion för att dela upp data i mindre subarrayer eller sublistor, sortera dem och sedan slå samman dem igen. Dela-och-härska-algoritmer: Många algoritmer som använder en dela-och-härska-metod, som den binära sökalgoritmen, använder rekursion för att bryta ner problemet i mindre delproblem. Fraktalgenerering: Fraktalformer och mönster kan genereras med hjälp av rekursiva algoritmer. Till exempel genereras Mandelbrot-mängden genom att upprepade gånger tillämpa en rekursiv formel på komplexa tal. Backtracking-algoritmer : Backtracking-algoritmer används för att lösa problem som innebär att man tar en sekvens av beslut, där varje beslut beror på de tidigare. Dessa algoritmer kan implementeras med hjälp av rekursion för att utforska alla möjliga vägar och backa när en lösning inte hittas. Memoization : Memoization är en teknik som innebär att man lagrar resultaten av dyra funktionsanrop och returnerar det cachade resultatet när samma inmatningar sker igen. Memoisering kan implementeras med hjälp av rekursiva funktioner för att beräkna och cacheresultat av delproblem.
Detta är bara några exempel på de många tillämpningarna av rekursion inom datavetenskap och programmering. Rekursion är ett mångsidigt och kraftfullt verktyg som kan användas för att lösa många olika typer av problem.
multithreading i java
Förklaring: ett verkligt exempel på rekursion:
Rekursion är en programmeringsteknik som innebär att en funktion anropar sig själv. Det kan vara ett kraftfullt verktyg för att lösa komplexa problem, men det kräver också noggrann implementering för att undvika oändliga loopar och stackoverflows.
Här är ett exempel på implementering av rekursion i 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> >}> }> |
>
>
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> |
>
>Produktion
120>
I det här exemplet definierar vi en funktion som kallas faktoriell som tar ett heltal n som indata. Funktionen använder rekursion för att beräkna faktorialen för n (dvs produkten av alla positiva heltal upp till n).
Faktorialfunktionen kontrollerar först om n är 0 eller 1, vilket är basfallen. Om n är 0 eller 1, returnerar funktionen 1, eftersom 0! och 1! är båda 1.
Om n är större än 1 går funktionen in i det rekursiva fallet. Den kallar sig själv med n-1 som argument och multiplicerar resultatet med n. Detta beräknar n! genom rekursiv beräkning (n-1)!.
Det är viktigt att notera att rekursion kan vara ineffektivt och leda till stackoverflows om den inte används försiktigt. Varje funktionsanrop lägger till en ny ram till anropsstacken, vilket kan göra att stacken blir för stor om rekursionen är för djup. Dessutom kan rekursion göra koden svårare att förstå och felsöka, eftersom den kräver att man tänker på flera nivåer av funktionsanrop.
Men rekursion kan också vara ett kraftfullt verktyg för att lösa komplexa problem, särskilt de som innebär att dela upp ett problem i mindre delproblem. När den används på rätt sätt kan rekursion göra koden mer elegant och lättare att läsa.
Vilka är nackdelarna med rekursiv programmering framför iterativ programmering?
Observera att både rekursiva och iterativa program har samma problemlösningsförmåga, d.v.s. varje rekursivt program kan skrivas iterativt och vice versa är också sant. Det rekursiva programmet har större utrymmeskrav än det iterativa programmet eftersom alla funktioner kommer att finnas kvar i stacken tills basfallet nås. Den har också större tidskrav på grund av funktionsanrop och returer.
Dessutom, på grund av den kortare längden på koden, är koderna svåra att förstå och därför måste extra försiktighet utövas när koden skrivs. Datorn kan ta slut på minne om de rekursiva samtalen inte kontrolleras ordentligt.
Vilka är fördelarna med rekursiv programmering framför iterativ programmering?
Rekursion ger ett rent och enkelt sätt att skriva kod. Vissa problem är till sin natur rekursiva som trädövergångar, Hanois torn , etc. För sådana problem är det föredraget att skriva rekursiv kod. Vi kan skriva sådana koder också iterativt med hjälp av en stackdatastruktur. Se till exempel Inorder Tree Traversal without Recursion, Iterative Tower of Hanoi.
Sammanfattning av återfall:
- Det finns två typer av fall i rekursion, det vill säga rekursivt fall och ett basfall.
- Basfallet används för att avsluta den rekursiva funktionen när fallet visar sig vara sant.
- Varje rekursivt anrop gör en ny kopia av den metoden i stackminnet.
- Oändlig rekursion kan leda till att stackminnet tar slut.
- Exempel på rekursiva algoritmer: Merge Sort, Quick Sort, Tower of Hanoi, Fibonacci Series, Factory Problem, etc.
Utgångsbaserade övningsproblem för nybörjare:
Övningsfrågor för rekursion | Set 1
Övningsfrågor för rekursion | Set 2
Övningsfrågor för rekursion | Set 3
Övningsfrågor för rekursion | Set 4
Övningsfrågor för rekursion | Set 5
Övningsfrågor för rekursion | Set 6
Övningsfrågor för rekursion | Set 7
Frågesport om Rekursion
Kodningsövningar för rekursion:
Alla artiklar om rekursion
Rekursiv övningsproblem med lösningar