Co je rekurze?
Proces, ve kterém se funkce přímo nebo nepřímo volá, se nazývá rekurze a odpovídající funkce se nazývá rekurzivní funkce. Pomocí rekurzivního algoritmu lze určité problémy vyřešit poměrně snadno. Příklady takových problémů jsou Hanojské věže (TOH) , Průchody stromů v pořadí/předobjednávky/postorderu , DFS of Graph atd. Rekurzivní funkce řeší konkrétní problém voláním své kopie a řešením menších dílčích problémů původních problémů. Podle potřeby lze generovat mnohem více rekurzivních volání. Je nezbytné vědět, že bychom měli poskytnout určitý případ, abychom tento proces rekurze ukončili. Můžeme tedy říci, že pokaždé, když se funkce zavolá sama s jednodušší verzí původního problému.
Potřeba rekurze
Rekurze je úžasná technika, s jejíž pomocí můžeme zkrátit délku našeho kódu a usnadnit jeho čtení a zápis. Oproti iterační technice má určité výhody, o kterých bude řeč později. Úloha, kterou lze definovat s podobnou dílčí úlohou, rekurze, je pro ni jedním z nejlepších řešení. Například; Faktoriál čísla.
Vlastnosti rekurze:
- Provádění stejných operací vícekrát s různými vstupy.
- V každém kroku zkoušíme menší vstupy, aby byl problém menší.
- Základní podmínka je nutná k zastavení rekurze, jinak dojde k nekonečné smyčce.
Algoritmus: Kroky
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.>
Matematická interpretace
Uvažujme problém, který musí programátor určit součet prvních n přirozených čísel, existuje několik způsobů, jak to udělat, ale nejjednodušší je jednoduše sečíst čísla od 1 do n. Takže funkce vypadá jednoduše takto,
přístup(1) – Jednoduše přidávejte jeden po druhém
f(n) = 1 + 2 + 3 +……..+ n
ale existuje jiný matematický přístup, jak to reprezentovat,
přístup(2) – Rekurzivní přidávání
f(n) = 1 n = 1
f(n) = n + f(n-1) n>1
Mezi přístupem (1) a přístupem (2) je jednoduchý rozdíl a to je in přístup (2) funkce f() sám se nazývá uvnitř funkce, takže tento jev se nazývá rekurze a funkce obsahující rekurzi se nazývá rekurzivní funkce, na konci je to skvělý nástroj v rukou programátorů, jak kódovat některé problémy mnohem snadněji a efektivněji. cesta.
Jak jsou rekurzivní funkce uloženy v paměti?
Rekurze využívá více paměti, protože rekurzivní funkce přidává do zásobníku s každým rekurzivním voláním a uchovává tam hodnoty, dokud není volání dokončeno. Rekurzivní funkce používá strukturu LIFO (LAST IN FIRST OUT) stejně jako datovou strukturu zásobníku. stack-data-structure/
Jaká je základní podmínka v rekurzi?
V rekurzivním programu je poskytováno řešení základního případu a řešení většího problému je vyjádřeno pomocí menších problémů.
int fact(int n) { if (n <= 1) // base case return 1; else return n*fact(n-1); }> Ve výše uvedeném příkladu je definován základní případ pro n <= 1 a větší hodnotu čísla lze vyřešit převodem na menší, dokud se nedosáhne základního případu.
Jak se řeší konkrétní problém pomocí rekurze?
Cílem je znázornit problém z hlediska jednoho nebo více menších problémů a přidat jednu nebo více základních podmínek, které zastaví rekurzi. Například počítáme faktoriál n, známe-li faktoriál (n-1). Základní případ pro faktoriál by byl n = 0. Když n = 0, vrátíme 1.
Proč při rekurzi dochází k chybě přetečení zásobníku?
Pokud není dosaženo základního případu nebo není definováno, může nastat problém s přetečením zásobníku. Vezměme si příklad, abychom to pochopili.
int fact(int n) { // wrong base case (it may cause // stack overflow). if (n == 100) return 1; else return n*fact(n-1); }> Pokud se zavolá fact(10), zavolá fact(9), fact(8), fact(7) a tak dále, ale číslo nikdy nedosáhne 100. Takže není dosaženo základního případu. Pokud je paměť vyčerpána těmito funkcemi na zásobníku, způsobí to chybu přetečení zásobníku.
Jaký je rozdíl mezi přímou a nepřímou rekurzí?
Funkcí fun se nazývá přímá rekurzivní, pokud volá stejnou funkci fun. Funkce fun se nazývá nepřímá rekurzivní, pokud volá jinou funkci, řekněme fun_new, a fun_new volá zábavu přímo nebo nepřímo. Rozdíl mezi přímou a nepřímou rekurzí je znázorněn v tabulce 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... }> Jaký je rozdíl mezi tailed a non-tailed rekurzí?
Rekurzivní funkce je koncová rekurzivní, když je rekurzivní volání poslední věcí, kterou funkce provede. Prosím odkažte článek o rekurzi ocasu pro detaily.
Jak je paměť přidělena různým voláním funkcí v rekurzi?
Když je jakákoli funkce volána z main(), je jí přidělena paměť na zásobníku. Rekurzivní funkce volá sama sebe, paměť pro volanou funkci je alokována nad pamětí přidělenou volající funkci a pro každé volání funkce je vytvořena jiná kopie lokálních proměnných. Když je dosaženo základního případu, funkce vrátí svou hodnotu funkci, kterou byla volána, a paměť je uvolněna a proces pokračuje.
Vezměme si příklad toho, jak funguje rekurze pomocí jednoduché funkce.
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);> }> |
>
>
Jáva
třída objektů v jazyce 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);> > > |
>
>Výstup
3 2 1 1 2 3>
Časová náročnost: O(1)
Pomocný prostor: O(1)
Když printFun(3) je volána z main(), paměť je přidělena printFun(3) a test lokální proměnné je inicializován na 3 a příkazy 1 až 4 jsou vloženy do zásobníku, jak je znázorněno na obrázku níže. Nejprve vytiskne „3“. V prohlášení 2, printFun(2) je volána a paměť je přidělena printFun(2) a test lokální proměnné je inicializován na 2 a příkazy 1 až 4 jsou vloženy do zásobníku. Podobně, printFun(2) hovory printFun(1) a printFun(1) hovory printFun(0) . printFun(0) přejde na příkaz if a vrátí se do printFun(1) . Zbývající prohlášení z printFun(1) jsou provedeny a vrátí se do printFun(2) a tak dále. Ve výstupu se vytisknou hodnoty od 3 do 1 a poté se vytisknou 1 až 3. Paměťový zásobník je znázorněn na obrázku níže.
Rekurze VS Iterace
| SR č. | Rekurze | Opakování |
| 1) | Ukončí se, když se základní případ stane pravdou. | Ukončí se, když se podmínka stane nepravdivou. |
| 2) | Používá se s funkcemi. | Používá se se smyčkami. |
| 3) | Každé rekurzivní volání potřebuje více místa v paměti zásobníku. | Každá iterace nevyžaduje žádný prostor navíc. |
| 4) | Menší velikost kódu. | Větší velikost kódu. |
Pojďme si nyní probrat několik praktických problémů, které lze vyřešit pomocí rekurze, a porozumět jejímu základnímu fungování. Pro základní pochopení si přečtěte následující články.
Základní pochopení rekurze.
Problém 1: Napište program a rekurenci pro nalezení Fibonacciho řady n, kde n>2 .
Matematická rovnice:
n if n == 0, n == 1; fib(n) = fib(n-1) + fib(n-2) otherwise;>
Vztah k opakování:
T(n) = T(n-1) + T(n-2) + O(1)>
Rekurzivní program:
Input: n = 5 Output: Fibonacci series of 5 numbers is : 0 1 1 2 3>
Implementace:
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; }> |
>
>
Jáva
// 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> |
>
>
řetězec concat java
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) + ' '); } > |
>
>Výstup
Fibonacci series of 5 numbers is: 0 1 1 2 3>
Časová náročnost: O(2n)
Pomocný prostor: Na)
Zde je rekurzivní strom pro vstup 5, který ukazuje jasný obrázek toho, jak lze velký problém vyřešit na menší.
fib(n) je Fibonacciho funkce. Časová náročnost daného programu může záviset na volání funkce.
fib(n) -> úroveň CBT (UB) -> 2^n-1 uzlů -> 2^n volání funkce -> 2^n*O(1) -> T(n) = O(2^n)
Pro nejlepší případ.
T(n) = ?(2^n2)>
Pracovní:
Problém 2: Napište program a rekurenci pro nalezení faktoriálu n kde n>2 .
Matematická rovnice:
1 if n == 0 or n == 1; f(n) = n*f(n-1) if n>1;>
Vztah k opakování:
T(n) = 1 for n = 0 T(n) = 1 + T(n-1) for n>0>
Rekurzivní program:
Vstup: n = 5
Výstup:
faktoriál 5 je: 120
Implementace:
C++
ymail
// 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;> }> |
>
>
Jáva
// 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.> > |
java inicializovat pole
>
>Výstup
factorial of 5 is: 120>
Časová složitost: Na)
Pomocný prostor: Na)
Pracovní:
Schéma faktoriální funkce rekurze pro uživatelský vstup 5.
Příklad: Reálné aplikace rekurze v reálných problémech
Rekurze je výkonná technika, která má mnoho aplikací v informatice a programování. Zde jsou některé z běžných aplikací rekurze:
- Procházení stromem a grafem: Rekurze se často používá k procházení a vyhledávání datových struktur, jako jsou stromy a grafy. Rekurzivní algoritmy lze použít k systematickému prozkoumání všech uzlů nebo vrcholů stromu nebo grafu. Algoritmy řazení: Rekurzivní algoritmy se také používají v algoritmech řazení, jako je quicksort a merge sort. Tyto algoritmy používají rekurzi k rozdělení dat do menších podpolí nebo podseznamů, k jejich třídění a následnému sloučení. Algoritmy rozděl a panuj : Mnoho algoritmů, které používají přístup rozděl a panuj, jako je binární vyhledávací algoritmus, používá rekurzi k rozdělení problému na menší dílčí problémy. Generování fraktálů: Fraktální tvary a vzory lze generovat pomocí rekurzivních algoritmů. Například Mandelbrotova množina je generována opakovaným aplikováním rekurzivního vzorce na komplexní čísla. Algoritmy zpětného sledování: Algoritmy zpětného sledování se používají k řešení problémů, které zahrnují posloupnost rozhodnutí, kde každé rozhodnutí závisí na předchozích. Tyto algoritmy lze implementovat pomocí rekurze k prozkoumání všech možných cest a zpětného sledování, když není nalezeno řešení. Memoizace: Memoizace je technika, která zahrnuje ukládání výsledků drahých volání funkcí a vrácení výsledku uloženého v mezipaměti, když se znovu objeví stejné vstupy. Memoizaci lze implementovat pomocí rekurzivních funkcí pro výpočet a ukládání výsledků dílčích problémů do mezipaměti.
To je jen několik příkladů z mnoha aplikací rekurze v informatice a programování. Rekurze je všestranný a výkonný nástroj, který lze použít k řešení mnoha různých typů problémů.
Vysvětlení: jeden skutečný příklad rekurze:
Rekurze je programovací technika, která zahrnuje volání samotné funkce. Může to být mocný nástroj pro řešení složitých problémů, ale také vyžaduje pečlivou implementaci, aby se zabránilo nekonečným smyčkám a přetečení zásobníku.
Zde je příklad implementace rekurze v Pythonu:
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 |
>
>
Jáva
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> |
>
>Výstup
120>
V tomto příkladu definujeme funkci nazvanou faktoriál, která má jako vstup celé číslo n. Funkce používá rekurzi k výpočtu faktoriálu n (tj. součinu všech kladných celých čísel až do n).
Faktoriál nejprve zkontroluje, zda n je 0 nebo 1, což jsou základní případy. Pokud je n 0 nebo 1, funkce vrátí 1, protože 0! a 1! jsou oba 1.
Pokud je n větší než 1, funkce vstoupí do rekurzivního případu. Volá se s argumentem n-1 a výsledek vynásobí n. Toto počítá n! rekurzivním výpočtem (n-1)!.
Je důležité si uvědomit, že rekurze může být neefektivní a vést k přetečení zásobníku, pokud není používána opatrně. Každé volání funkce přidá do zásobníku volání nový rámec, což může způsobit, že se zásobník příliš zvětší, pokud je rekurze příliš hluboká. Kromě toho může rekurze ztížit pochopení a ladění kódu, protože vyžaduje přemýšlet o více úrovních volání funkcí.
Rekurze však může být také mocným nástrojem pro řešení složitých problémů, zejména těch, které zahrnují rozdělení problému na menší dílčí problémy. Při správném použití může rekurze kód učinit elegantnějším a snadněji čitelným.
Jaké jsou nevýhody rekurzivního programování oproti iterativnímu programování?
Všimněte si, že jak rekurzivní, tak iterativní programy mají stejné schopnosti řešit problémy, tj. každý rekurzivní program lze psát iterativně a platí to i naopak. Rekurzivní program má větší nároky na prostor než iterativní program, protože všechny funkce zůstanou v zásobníku, dokud není dosaženo základního případu. Má také větší časové nároky z důvodu režie volání funkcí a návratů.
Navíc kvůli menší délce kódu jsou kódy obtížně srozumitelné, a proto je třeba při psaní kódu věnovat zvýšenou pozornost. Pokud nejsou rekurzivní volání správně zkontrolována, může dojít k nedostatku paměti.
Jaké jsou výhody rekurzivního programování oproti iterativnímu programování?
Rekurze poskytuje čistý a jednoduchý způsob psaní kódu. Některé problémy jsou ze své podstaty rekurzivní jako procházení stromů, Hanojská věž , atd. Pro takové problémy je preferováno psát rekurzivní kód. Takové kódy můžeme psát i iterativně pomocí zásobníkové datové struktury. Podívejte se například na Inorder Tree Traversal bez rekurze, Iterativní věž v Hanoji.
Shrnutí rekurze:
- V rekurzi existují dva typy případů, tj. rekurzivní případ a základní případ.
- Základní případ se používá k ukončení rekurzivní funkce, když se případ ukáže jako pravdivý.
- Každé rekurzivní volání vytvoří novou kopii této metody v paměti zásobníku.
- Nekonečná rekurze může vést k nedostatku paměti zásobníku.
- Příklady rekurzivních algoritmů: Merge Sort, Rychlé řazení, Hanojská věž, Fibonacciho řada, Factorial Problem atd.
Cvičné problémy založené na výstupu pro začátečníky:
Cvičné otázky pro rekurzi | Sada 1
Cvičné otázky pro rekurzi | Sada 2
Cvičné otázky pro rekurzi | Sada 3
Cvičné otázky pro rekurzi | Sada 4
Cvičné otázky pro rekurzi | Sada 5
Cvičné otázky pro rekurzi | Sada 6
Cvičné otázky pro rekurzi | Sada 7
Kvíz o rekurzi
Praxe kódování na rekurzi:
Všechny články o rekurzi
Problémy s rekurzivní praxí s řešeními